diff --git a/src/assets/view/widgets/keywordparamwidget.cpp b/src/assets/view/widgets/keywordparamwidget.cpp
index 38dc99783..6a8e4f620 100644
--- a/src/assets/view/widgets/keywordparamwidget.cpp
+++ b/src/assets/view/widgets/keywordparamwidget.cpp
@@ -1,83 +1,79 @@
 /***************************************************************************
  *   Copyright (C) 2016 by 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 "keywordparamwidget.hpp"
 #include "assets/model/assetparametermodel.hpp"
 
 KeywordParamWidget::KeywordParamWidget(std::shared_ptr<AssetParameterModel> model, QModelIndex index, QWidget *parent)
     : AbstractParamWidget(std::move(model), index, parent)
 {
     setupUi(this);
 
     // setup the comment
     QString name = m_model->data(m_index, AssetParameterModel::NameRole).toString();
     QString comment = m_model->data(m_index, AssetParameterModel::CommentRole).toString();
     setToolTip(comment);
 
     // setup the name
     label->setText(m_model->data(m_index, Qt::DisplayRole).toString());
     
     QStringList kwrdValues = m_model->data(m_index, AssetParameterModel::ListValuesRole).toStringList();
     QStringList kwrdNames = m_model->data(m_index, AssetParameterModel::ListNamesRole).toStringList();
     comboboxwidget->addItems(kwrdNames);
     int i = 0;
     for (const QString &keywordVal : kwrdValues) {
         if (i >= comboboxwidget->count()) {
             break;
         }
         comboboxwidget->setItemData(i, keywordVal);
         i++;
     }
     comboboxwidget->insertItem(0, i18n("<select a keyword>"));
     comboboxwidget->setCurrentIndex(0);
     // set check state
     slotRefresh();
     setMinimumHeight(comboboxwidget->sizeHint().height());
 
     // emit the signal of the base class when appropriate
     connect(lineeditwidget, &QLineEdit::editingFinished, [this]() { 
         emit valueChanged(m_index, lineeditwidget->text(), true);
     });
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(comboboxwidget, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
-#else
-    connect(comboboxwidget, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) ,
-#endif
             [this](int ix) {
             if (ix > 0) {
                 QString comboval = comboboxwidget->itemData(ix).toString();
                 this->lineeditwidget->insert(comboval);
                 emit valueChanged(m_index, lineeditwidget->text(), true);
                 comboboxwidget->setCurrentIndex(0);
             }
     });
 }
 
 void KeywordParamWidget::slotShowComment(bool show)
 {
     Q_UNUSED(show);
 }
 
 void KeywordParamWidget::slotRefresh()
 {
     lineeditwidget->setText(m_model->data(m_index, AssetParameterModel::ValueRole).toString());
 }
 
diff --git a/src/assets/view/widgets/listparamwidget.cpp b/src/assets/view/widgets/listparamwidget.cpp
index a76784e76..fa8144f82 100644
--- a/src/assets/view/widgets/listparamwidget.cpp
+++ b/src/assets/view/widgets/listparamwidget.cpp
@@ -1,153 +1,149 @@
 /***************************************************************************
  *   Copyright (C) 2016 by 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 "listparamwidget.h"
 #include "assets/model/assetparametermodel.hpp"
 #include "core.h"
 #include "mainwindow.h"
 
 ListParamWidget::ListParamWidget(std::shared_ptr<AssetParameterModel> model, QModelIndex index, QWidget *parent)
     : AbstractParamWidget(std::move(model), index, parent)
 {
     setupUi(this);
 
     // Get data from model
     QString name = m_model->data(m_index, AssetParameterModel::NameRole).toString();
     QString comment = m_model->data(m_index, AssetParameterModel::CommentRole).toString();
 
     // setup the comment
     setToolTip(comment);
     m_labelComment->setText(comment);
     m_widgetComment->setHidden(true);
     setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     m_list->setIconSize(QSize(50, 30));
     setMinimumHeight(m_list->sizeHint().height());
     // setup the name
     m_labelName->setText(m_model->data(m_index, Qt::DisplayRole).toString());
     slotRefresh();
 
     // emit the signal of the base class when appropriate
     // The connection is ugly because the signal "currentIndexChanged" is overloaded in QComboBox
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(this->m_list, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
-#else
-    connect(this->m_list, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) ,
-#endif
             [this](int) {
                 emit valueChanged(m_index, m_list->itemData(m_list->currentIndex()).toString(), true);
     });
 }
 
 void ListParamWidget::setCurrentIndex(int index)
 {
     m_list->setCurrentIndex(index);
 }
 
 void ListParamWidget::setCurrentText(const QString &text)
 {
     m_list->setCurrentText(text);
 }
 
 void ListParamWidget::addItem(const QString &text, const QVariant &value)
 {
     m_list->addItem(text, value);
 }
 
 void ListParamWidget::setItemIcon(int index, const QIcon &icon)
 {
     m_list->setItemIcon(index, icon);
 }
 
 void ListParamWidget::setIconSize(const QSize &size)
 {
     m_list->setIconSize(size);
 }
 
 void ListParamWidget::slotShowComment(bool show)
 {
     if (!m_labelComment->text().isEmpty()) {
         m_widgetComment->setVisible(show);
     }
 }
 
 QString ListParamWidget::getValue()
 {
     return m_list->currentData().toString();
 }
 
 void ListParamWidget::slotRefresh()
 {
     const QSignalBlocker bk(m_list);
     m_list->clear();
     QStringList names = m_model->data(m_index, AssetParameterModel::ListNamesRole).toStringList();
     QStringList values = m_model->data(m_index, AssetParameterModel::ListValuesRole).toStringList();
     QString value = m_model->data(m_index, AssetParameterModel::ValueRole).toString();
     if (values.first() == QLatin1String("%lumaPaths")) {
         // Special case: Luma files
         // Create thumbnails
         if (pCore->getCurrentFrameSize().width() > 1000) {
             // HD project
             values = MainWindow::m_lumaFiles.value(QStringLiteral("16_9"));
         } else if (pCore->getCurrentFrameSize().height() > 1000) {
             values = MainWindow::m_lumaFiles.value(QStringLiteral("9_16"));
         } else if (pCore->getCurrentFrameSize().height() == pCore->getCurrentFrameSize().width()) {
             values = MainWindow::m_lumaFiles.value(QStringLiteral("square"));
         } else if (pCore->getCurrentFrameSize().height() == 480) {
             values = MainWindow::m_lumaFiles.value(QStringLiteral("NTSC"));
         } else {
             values = MainWindow::m_lumaFiles.value(QStringLiteral("PAL"));
         }
         m_list->addItem(i18n("None (Dissolve)"));
         for (int j = 0; j < values.count(); ++j) {
             const QString &entry = values.at(j);
             m_list->addItem(values.at(j).section(QLatin1Char('/'), -1), entry);
             if (!entry.isEmpty() && (entry.endsWith(QLatin1String(".png")) || entry.endsWith(QLatin1String(".pgm")))) {
                 if (MainWindow::m_lumacache.contains(entry)) {
                     m_list->setItemIcon(j + 1, QPixmap::fromImage(MainWindow::m_lumacache.value(entry)));
                 }
             }
         }
         if (!value.isEmpty() && values.contains(value)) {
             m_list->setCurrentIndex(values.indexOf(value) + 1);
         }
     } else {
         if (names.count() != values.count()) {
             names = values;
         }
         QLocale locale;
         locale.setNumberOptions(QLocale::OmitGroupSeparator);
         for (int i = 0; i < names.count(); i++) {
             QString val = values.at(i);
             bool ok;
             double num = val.toDouble(&ok);
             if (ok) {
                 val = locale.toString(num);
             }
             m_list->addItem(names.at(i), val);
         }
         if (!value.isEmpty()) {
             int ix = m_list->findData(value);
             if (ix > -1)  {
                 m_list->setCurrentIndex(ix);
             }
         }
     }
 }
diff --git a/src/dialogs/encodingprofilesdialog.cpp b/src/dialogs/encodingprofilesdialog.cpp
index 89870f7b4..ec6bd55fc 100644
--- a/src/dialogs/encodingprofilesdialog.cpp
+++ b/src/dialogs/encodingprofilesdialog.cpp
@@ -1,194 +1,190 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "encodingprofilesdialog.h"
 
 #include "kdenlivesettings.h"
 
 #include "klocalizedstring.h"
 #include <QLineEdit>
 #include <QPlainTextEdit>
 #include <QStandardPaths>
 #include <QVBoxLayout>
 
 EncodingProfilesDialog::EncodingProfilesDialog(int profileType, QWidget *parent)
     : QDialog(parent)
     , m_configGroup(nullptr)
 {
     setupUi(this);
     setWindowTitle(i18n("Manage Encoding Profiles"));
     profile_type->addItem(i18n("Proxy clips"), 0);
     profile_type->addItem(i18n("Timeline preview"), 1);
     profile_type->addItem(i18n("Video4Linux capture"), 2);
     profile_type->addItem(i18n("Screen capture"), 3);
     profile_type->addItem(i18n("Decklink capture"), 4);
 
     button_add->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
     button_edit->setIcon(QIcon::fromTheme(QStringLiteral("document-edit")));
     button_delete->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
     button_download->setIcon(QIcon::fromTheme(QStringLiteral("download")));
 
     m_configFile = new KConfig(QStringLiteral("encodingprofiles.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     profile_type->setCurrentIndex(profileType);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(profile_type, static_cast<void (KComboBox::*)(int)>(&KComboBox::currentIndexChanged), this, &EncodingProfilesDialog::slotLoadProfiles);
-#else
-    connect(profile_type, static_cast<void (KComboBox::*)(int, const QString &)>(&KComboBox::currentIndexChanged) , this, &EncodingProfilesDialog::slotLoadProfiles);
-#endif
     connect(profile_list, &QListWidget::currentRowChanged, this, &EncodingProfilesDialog::slotShowParams);
     connect(button_delete, &QAbstractButton::clicked, this, &EncodingProfilesDialog::slotDeleteProfile);
     connect(button_add, &QAbstractButton::clicked, this, &EncodingProfilesDialog::slotAddProfile);
     connect(button_edit, &QAbstractButton::clicked, this, &EncodingProfilesDialog::slotEditProfile);
     profile_parameters->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
     slotLoadProfiles();
 }
 
 EncodingProfilesDialog::~EncodingProfilesDialog()
 {
     delete m_configGroup;
     delete m_configFile;
 }
 
 void EncodingProfilesDialog::slotLoadProfiles()
 {
     profile_list->blockSignals(true);
     profile_list->clear();
     QString group;
     switch (profile_type->currentIndex()) {
     case 0:
         group = QStringLiteral("proxy");
         break;
     case 2:
         group = QStringLiteral("video4linux");
         break;
     case 3:
         group = QStringLiteral("screengrab");
         break;
     case 4:
         group = QStringLiteral("decklink");
         break;
     case 1:
     default:
         group = QStringLiteral("timelinepreview");
         break;
     }
 
     delete m_configGroup;
     m_configGroup = new KConfigGroup(m_configFile, group);
     QMap<QString, QString> values = m_configGroup->entryMap();
     QMapIterator<QString, QString> i(values);
     while (i.hasNext()) {
         i.next();
         auto *item = new QListWidgetItem(i.key(), profile_list);
         item->setData(Qt::UserRole, i.value());
         // cout << i.key() << ": " << i.value() << endl;
     }
     profile_list->blockSignals(false);
     profile_list->setCurrentRow(0);
     const bool multiProfile(profile_list->count() > 0);
     button_delete->setEnabled(multiProfile);
     button_edit->setEnabled(multiProfile);
 }
 
 void EncodingProfilesDialog::slotShowParams()
 {
     profile_parameters->clear();
     QListWidgetItem *item = profile_list->currentItem();
     if (!item) {
         return;
     }
     profile_parameters->setPlainText(item->data(Qt::UserRole).toString().section(QLatin1Char(';'), 0, 0));
 }
 
 void EncodingProfilesDialog::slotDeleteProfile()
 {
     QListWidgetItem *item = profile_list->currentItem();
     if (!item) {
         return;
     }
     QString profile = item->text();
     m_configGroup->deleteEntry(profile);
     slotLoadProfiles();
 }
 
 void EncodingProfilesDialog::slotAddProfile()
 {
     QPointer<QDialog> d = new QDialog(this);
     auto *l = new QVBoxLayout;
     l->addWidget(new QLabel(i18n("Profile name:")));
     auto *pname = new QLineEdit;
     l->addWidget(pname);
     l->addWidget(new QLabel(i18n("Parameters:")));
     auto *pparams = new QPlainTextEdit;
     l->addWidget(pparams);
     l->addWidget(new QLabel(i18n("File extension:")));
     auto *pext = new QLineEdit;
     l->addWidget(pext);
     QDialogButtonBox *box = new QDialogButtonBox(QDialogButtonBox::Save | QDialogButtonBox::Cancel);
     connect(box, &QDialogButtonBox::accepted, d.data(), &QDialog::accept);
     connect(box, &QDialogButtonBox::rejected, d.data(), &QDialog::reject);
     l->addWidget(box);
     d->setLayout(l);
 
     QListWidgetItem *item = profile_list->currentItem();
     if (item) {
         QString profilestr = item->data(Qt::UserRole).toString();
         pparams->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
         pext->setText(profilestr.section(QLatin1Char(';'), 1, 1));
     }
     if (d->exec() == QDialog::Accepted) {
         m_configGroup->writeEntry(pname->text(), pparams->toPlainText() + QLatin1Char(';') + pext->text());
         slotLoadProfiles();
     }
     delete d;
 }
 
 void EncodingProfilesDialog::slotEditProfile()
 {
     QPointer<QDialog> d = new QDialog(this);
     auto *l = new QVBoxLayout;
     l->addWidget(new QLabel(i18n("Profile name:")));
     auto *pname = new QLineEdit;
     l->addWidget(pname);
     l->addWidget(new QLabel(i18n("Parameters:")));
     auto *pparams = new QPlainTextEdit;
     l->addWidget(pparams);
     l->addWidget(new QLabel(i18n("File extension:")));
     auto *pext = new QLineEdit;
     l->addWidget(pext);
     QDialogButtonBox *box = new QDialogButtonBox(QDialogButtonBox::Save | QDialogButtonBox::Cancel);
     connect(box, &QDialogButtonBox::accepted, d.data(), &QDialog::accept);
     connect(box, &QDialogButtonBox::rejected, d.data(), &QDialog::reject);
     l->addWidget(box);
     d->setLayout(l);
 
     QListWidgetItem *item = profile_list->currentItem();
     if (item) {
         pname->setText(item->text());
         QString profilestr = item->data(Qt::UserRole).toString();
         pparams->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
         pext->setText(profilestr.section(QLatin1Char(';'), 1, 1));
         pparams->setFocus();
     }
     if (d->exec() == QDialog::Accepted) {
         m_configGroup->writeEntry(pname->text(), pparams->toPlainText().simplified() + QLatin1Char(';') + pext->text());
         slotLoadProfiles();
     }
     delete d;
 }
diff --git a/src/dialogs/kdenlivesettingsdialog.cpp b/src/dialogs/kdenlivesettingsdialog.cpp
index 9dd32d224..77b2daa28 100644
--- a/src/dialogs/kdenlivesettingsdialog.cpp
+++ b/src/dialogs/kdenlivesettingsdialog.cpp
@@ -1,1701 +1,1649 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "kdenlivesettingsdialog.h"
 #include "clipcreationdialog.h"
 #include "core.h"
 #include "dialogs/profilesdialog.h"
 #include "encodingprofilesdialog.h"
 #include "kdenlivesettings.h"
 #include "profiles/profilemodel.hpp"
 #include "profiles/profilerepository.hpp"
 #include "profilesdialog.h"
 #include "project/dialogs/profilewidget.h"
 
 #ifdef USE_V4L
 #include "capture/v4lcapture.h"
 #endif
 
 #include "kdenlive_debug.h"
 #include "klocalizedstring.h"
 #include <KIO/DesktopExecParser>
 #include <KLineEdit>
 #include <KMessageBox>
 #include <KOpenWithDialog>
 #include <KService>
 #include <QAction>
 #include <QDir>
 #include <QGuiApplication>
 #include <QScreen>
 #include <QSize>
 #include <QThread>
 #include <QTimer>
 #include <cstdio>
 #include <cstdlib>
 #include <fcntl.h>
 #include <unistd.h>
 
 #ifdef USE_JOGSHUTTLE
 #include "jogshuttle/jogaction.h"
 #include "jogshuttle/jogshuttleconfig.h"
 #include <QStandardPaths>
 #include <linux/input.h>
 #endif
 
 KdenliveSettingsDialog::KdenliveSettingsDialog(QMap<QString, QString> mappable_actions, bool gpuAllowed, QWidget *parent)
     : KConfigDialog(parent, QStringLiteral("settings"), KdenliveSettings::self())
     , m_modified(false)
     , m_shuttleModified(false)
     , m_mappable_actions(std::move(mappable_actions))
 {
     KdenliveSettings::setV4l_format(0);
     QWidget *p1 = new QWidget;
     QFontInfo ftInfo(font());
     m_configMisc.setupUi(p1);
     m_page1 = addPage(p1, i18n("Misc"));
     m_page1->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
 
     m_configMisc.kcfg_use_exiftool->setEnabled(!QStandardPaths::findExecutable(QStringLiteral("exiftool")).isEmpty());
 
     QWidget *p8 = new QWidget;
     m_configProject.setupUi(p8);
     m_page8 = addPage(p8, i18n("Project Defaults"));
     auto *vbox = new QVBoxLayout;
     m_pw = new ProfileWidget(this);
     vbox->addWidget(m_pw);
     m_configProject.profile_box->setLayout(vbox);
     m_configProject.profile_box->setTitle(i18n("Select the default profile (preset)"));
     // Select profile
     m_pw->loadProfile(KdenliveSettings::default_profile().isEmpty() ? pCore->getCurrentProfile()->path() : KdenliveSettings::default_profile());
     connect(m_pw, &ProfileWidget::profileChanged, this, &KdenliveSettingsDialog::slotDialogModified);
     m_page8->setIcon(QIcon::fromTheme(QStringLiteral("project-defaults")));
     m_configProject.projecturl->setMode(KFile::Directory);
     m_configProject.projecturl->setUrl(QUrl::fromLocalFile(KdenliveSettings::defaultprojectfolder()));
     connect(m_configProject.kcfg_videotracks, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), [this]() {
         if (m_configProject.kcfg_videotracks->value() + m_configProject.kcfg_audiotracks->value() <= 0) {
             m_configProject.kcfg_videotracks->setValue(1);
         }
     });
     connect(m_configProject.kcfg_audiotracks, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), [this] () {
         if (m_configProject.kcfg_videotracks->value() + m_configProject.kcfg_audiotracks->value() <= 0) {
             m_configProject.kcfg_audiotracks->setValue(1);
         }
     });
 
     QWidget *p9 = new QWidget;
     m_configProxy.setupUi(p9);
     KPageWidgetItem *page9 = addPage(p9, i18n("Proxy Clips"));
     page9->setIcon(QIcon::fromTheme(QStringLiteral("zoom-out")));
     connect(m_configProxy.kcfg_generateproxy, &QAbstractButton::toggled, m_configProxy.kcfg_proxyminsize, &QWidget::setEnabled);
     m_configProxy.kcfg_proxyminsize->setEnabled(KdenliveSettings::generateproxy());
     connect(m_configProxy.kcfg_generateimageproxy, &QAbstractButton::toggled, m_configProxy.kcfg_proxyimageminsize, &QWidget::setEnabled);
     m_configProxy.kcfg_proxyimageminsize->setEnabled(KdenliveSettings::generateimageproxy());
     loadExternalProxyProfiles();
 
     QWidget *p3 = new QWidget;
     m_configTimeline.setupUi(p3);
     m_page3 = addPage(p3, i18n("Timeline"));
     m_page3->setIcon(QIcon::fromTheme(QStringLiteral("video-display")));
     m_configTimeline.kcfg_trackheight->setMinimum(ftInfo.pixelSize() * 1.5);
 
     QWidget *p2 = new QWidget;
     m_configEnv.setupUi(p2);
     m_configEnv.mltpathurl->setMode(KFile::Directory);
     m_configEnv.mltpathurl->lineEdit()->setObjectName(QStringLiteral("kcfg_mltpath"));
     m_configEnv.rendererpathurl->lineEdit()->setObjectName(QStringLiteral("kcfg_rendererpath"));
     m_configEnv.ffmpegurl->lineEdit()->setObjectName(QStringLiteral("kcfg_ffmpegpath"));
     m_configEnv.ffplayurl->lineEdit()->setObjectName(QStringLiteral("kcfg_ffplaypath"));
     m_configEnv.ffprobeurl->lineEdit()->setObjectName(QStringLiteral("kcfg_ffprobepath"));
     int maxThreads = QThread::idealThreadCount();
     m_configEnv.kcfg_mltthreads->setMaximum(maxThreads > 2 ? maxThreads : 8);
     m_configEnv.tmppathurl->setMode(KFile::Directory);
     m_configEnv.tmppathurl->lineEdit()->setObjectName(QStringLiteral("kcfg_currenttmpfolder"));
     m_configEnv.capturefolderurl->setMode(KFile::Directory);
     m_configEnv.capturefolderurl->lineEdit()->setObjectName(QStringLiteral("kcfg_capturefolder"));
     m_configEnv.capturefolderurl->setEnabled(!KdenliveSettings::capturetoprojectfolder());
     connect(m_configEnv.kcfg_capturetoprojectfolder, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotEnableCaptureFolder);
     // Library folder
     m_configEnv.libraryfolderurl->setMode(KFile::Directory);
     m_configEnv.libraryfolderurl->lineEdit()->setObjectName(QStringLiteral("kcfg_libraryfolder"));
     m_configEnv.libraryfolderurl->setEnabled(!KdenliveSettings::librarytodefaultfolder());
     m_configEnv.kcfg_librarytodefaultfolder->setToolTip(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/library"));
     connect(m_configEnv.kcfg_librarytodefaultfolder, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotEnableLibraryFolder);
 
     // Mime types
     QStringList mimes = ClipCreationDialog::getExtensions();
     std::sort(mimes.begin(), mimes.end());
     m_configEnv.supportedmimes->setPlainText(mimes.join(QLatin1Char(' ')));
 
     m_page2 = addPage(p2, i18n("Environment"));
     m_page2->setIcon(QIcon::fromTheme(QStringLiteral("application-x-executable-script")));
 
     QWidget *p4 = new QWidget;
     m_configCapture.setupUi(p4);
     // Remove ffmpeg tab, unused
     m_configCapture.tabWidget->removeTab(0);
     m_configCapture.label->setVisible(false);
     m_configCapture.kcfg_defaultcapture->setVisible(false);
     //m_configCapture.tabWidget->removeTab(2);
 #ifdef USE_V4L
 
     // Video 4 Linux device detection
     for (int i = 0; i < 10; ++i) {
         QString path = QStringLiteral("/dev/video") + QString::number(i);
         if (QFile::exists(path)) {
             QStringList deviceInfo = V4lCaptureHandler::getDeviceName(path);
             if (!deviceInfo.isEmpty()) {
                 m_configCapture.kcfg_detectedv4ldevices->addItem(deviceInfo.at(0), path);
                 m_configCapture.kcfg_detectedv4ldevices->setItemData(m_configCapture.kcfg_detectedv4ldevices->count() - 1, deviceInfo.at(1), Qt::UserRole + 1);
             }
         }
     }
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_detectedv4ldevices, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.kcfg_detectedv4ldevices, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdatev4lDevice);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_v4l_format, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.kcfg_v4l_format, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdatev4lCaptureProfile);
     connect(m_configCapture.config_v4l, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotEditVideo4LinuxProfile);
 
     slotUpdatev4lDevice();
 #endif
 
     m_page4 = addPage(p4, i18n("Capture"));
     m_page4->setIcon(QIcon::fromTheme(QStringLiteral("media-record")));
     m_configCapture.tabWidget->setCurrentIndex(KdenliveSettings::defaultcapture());
 #ifdef Q_WS_MAC
     m_configCapture.tabWidget->setEnabled(false);
     m_configCapture.kcfg_defaultcapture->setEnabled(false);
     m_configCapture.label->setText(i18n("Capture is not yet available on Mac OS X."));
 #endif
 
     QWidget *p5 = new QWidget;
     m_configShuttle.setupUi(p5);
 #ifdef USE_JOGSHUTTLE
     m_configShuttle.toolBtnReload->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
     connect(m_configShuttle.kcfg_enableshuttle, &QCheckBox::stateChanged, this, &KdenliveSettingsDialog::slotCheckShuttle);
     connect(m_configShuttle.shuttledevicelist, SIGNAL(activated(int)), this, SLOT(slotUpdateShuttleDevice(int)));
     connect(m_configShuttle.toolBtnReload, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotReloadShuttleDevices);
 
     slotCheckShuttle(static_cast<int>(KdenliveSettings::enableshuttle()));
     m_configShuttle.shuttledisabled->hide();
 
     // Store the button pointers into an array for easier handling them in the other functions.
     // TODO: impl enumerator or live with cut and paste :-)))
     setupJogshuttleBtns(KdenliveSettings::shuttledevice());
 #if 0
     m_shuttle_buttons.push_back(m_configShuttle.shuttle1);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle2);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle3);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle4);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle5);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle6);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle7);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle8);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle9);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle10);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle11);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle12);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle13);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle14);
     m_shuttle_buttons.push_back(m_configShuttle.shuttle15);
 #endif
 
 #else  /* ! USE_JOGSHUTTLE */
     m_configShuttle.kcfg_enableshuttle->hide();
     m_configShuttle.kcfg_enableshuttle->setDisabled(true);
 #endif /* USE_JOGSHUTTLE */
     m_page5 = addPage(p5, i18n("JogShuttle"));
     m_page5->setIcon(QIcon::fromTheme(QStringLiteral("jog-dial")));
 
     QWidget *p6 = new QWidget;
     m_configSdl.setupUi(p6);
     m_configSdl.reload_blackmagic->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
     connect(m_configSdl.reload_blackmagic, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotReloadBlackMagic);
 
     // m_configSdl.kcfg_openglmonitors->setHidden(true);
 
     m_page6 = addPage(p6, i18n("Playback"));
     m_page6->setIcon(QIcon::fromTheme(QStringLiteral("media-playback-start")));
 
     QWidget *p7 = new QWidget;
     m_configTranscode.setupUi(p7);
     m_page7 = addPage(p7, i18n("Transcode"));
     m_page7->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
 
     connect(m_configTranscode.button_add, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotAddTranscode);
     connect(m_configTranscode.button_delete, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotDeleteTranscode);
     connect(m_configTranscode.profiles_list, &QListWidget::itemChanged, this, &KdenliveSettingsDialog::slotDialogModified);
     connect(m_configTranscode.profiles_list, &QListWidget::currentRowChanged, this, &KdenliveSettingsDialog::slotSetTranscodeProfile);
 
     connect(m_configTranscode.profile_name, &QLineEdit::textChanged, this, &KdenliveSettingsDialog::slotEnableTranscodeUpdate);
     connect(m_configTranscode.profile_description, &QLineEdit::textChanged, this, &KdenliveSettingsDialog::slotEnableTranscodeUpdate);
     connect(m_configTranscode.profile_extension, &QLineEdit::textChanged, this, &KdenliveSettingsDialog::slotEnableTranscodeUpdate);
     connect(m_configTranscode.profile_parameters, &QPlainTextEdit::textChanged, this, &KdenliveSettingsDialog::slotEnableTranscodeUpdate);
     connect(m_configTranscode.profile_audioonly, &QCheckBox::stateChanged, this, &KdenliveSettingsDialog::slotEnableTranscodeUpdate);
 
     connect(m_configTranscode.button_update, &QAbstractButton::pressed, this, &KdenliveSettingsDialog::slotUpdateTranscodingProfile);
 
     m_configTranscode.profile_parameters->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
 
     connect(m_configEnv.kp_image, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotEditImageApplication);
     connect(m_configEnv.kp_audio, &QAbstractButton::clicked, this, &KdenliveSettingsDialog::slotEditAudioApplication);
 
     loadEncodingProfiles();
 
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configSdl.kcfg_audio_driver, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configSdl.kcfg_audio_driver, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotCheckAlsaDriver);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configSdl.kcfg_audio_backend, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configSdl.kcfg_audio_backend, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotCheckAudioBackend);
     initDevices();
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_grab_capture_type, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.kcfg_grab_capture_type, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateGrabRegionStatus);
 
     slotUpdateGrabRegionStatus();
     loadTranscodeProfiles();
 
     // decklink profile
     QAction *act = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure profiles"), this);
     act->setData(4);
     connect(act, &QAction::triggered, this, &KdenliveSettingsDialog::slotManageEncodingProfile);
     m_configCapture.decklink_manageprofile->setDefaultAction(act);
     m_configCapture.decklink_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     m_configCapture.decklink_parameters->setVisible(false);
     m_configCapture.decklink_parameters->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 4);
     m_configCapture.decklink_parameters->setPlainText(KdenliveSettings::decklink_parameters());
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_decklink_profile, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.kcfg_decklink_profile, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateDecklinkProfile);
     connect(m_configCapture.decklink_showprofileinfo, &QAbstractButton::clicked, m_configCapture.decklink_parameters, &QWidget::setVisible);
 
     // ffmpeg profile
     m_configCapture.v4l_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     m_configCapture.v4l_parameters->setVisible(false);
     m_configCapture.v4l_parameters->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 4);
     m_configCapture.v4l_parameters->setPlainText(KdenliveSettings::v4l_parameters());
 
     act = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure profiles"), this);
     act->setData(2);
     connect(act, &QAction::triggered, this, &KdenliveSettingsDialog::slotManageEncodingProfile);
     m_configCapture.v4l_manageprofile->setDefaultAction(act);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_v4l_profile, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.kcfg_v4l_profile, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateV4lProfile);
     connect(m_configCapture.v4l_showprofileinfo, &QAbstractButton::clicked, m_configCapture.v4l_parameters, &QWidget::setVisible);
 
     // screen grab profile
     m_configCapture.grab_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     m_configCapture.grab_parameters->setVisible(false);
     m_configCapture.grab_parameters->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 4);
     m_configCapture.grab_parameters->setPlainText(KdenliveSettings::grab_parameters());
     act = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure profiles"), this);
     act->setData(3);
     connect(act, &QAction::triggered, this, &KdenliveSettingsDialog::slotManageEncodingProfile);
     m_configCapture.grab_manageprofile->setDefaultAction(act);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_grab_profile, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.kcfg_grab_profile, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateGrabProfile);
     connect(m_configCapture.grab_showprofileinfo, &QAbstractButton::clicked, m_configCapture.grab_parameters, &QWidget::setVisible);
 
     // audio capture channels
     m_configCapture.audiocapturechannels->clear();
     m_configCapture.audiocapturechannels->addItem(i18n("Mono (1 channel)"), 1);
     m_configCapture.audiocapturechannels->addItem(i18n("Stereo (2 channels)"), 2);
 
     int channelsIndex = m_configCapture.audiocapturechannels->findData(KdenliveSettings::audiocapturechannels());
     m_configCapture.audiocapturechannels->setCurrentIndex(qMax(channelsIndex, 0));
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.audiocapturechannels, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.audiocapturechannels, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateAudioCaptureChannels);
 
     // audio capture sample rate
     m_configCapture.audiocapturesamplerate->clear();
     m_configCapture.audiocapturesamplerate->addItem(i18n("44100 Hz"), 44100);
     m_configCapture.audiocapturesamplerate->addItem(i18n("48000 Hz"), 48000);
 
     int sampleRateIndex = m_configCapture.audiocapturesamplerate->findData(KdenliveSettings::audiocapturesamplerate());
     m_configCapture.audiocapturesamplerate->setCurrentIndex(qMax(sampleRateIndex, 0));
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.audiocapturesamplerate, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configCapture.audiocapturesamplerate, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateAudioCaptureSampleRate);
 
     m_configCapture.labelNoAudioDevices->setVisible(false);
 
     // Timeline preview
     act = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure profiles"), this);
     act->setData(1);
     connect(act, &QAction::triggered, this, &KdenliveSettingsDialog::slotManageEncodingProfile);
     m_configProject.preview_manageprofile->setDefaultAction(act);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configProject.kcfg_preview_profile, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configProject.kcfg_preview_profile, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdatePreviewProfile);
     connect(m_configProject.preview_showprofileinfo, &QAbstractButton::clicked, m_configProject.previewparams, &QWidget::setVisible);
     m_configProject.previewparams->setVisible(false);
     m_configProject.previewparams->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 3);
     m_configProject.previewparams->setPlainText(KdenliveSettings::previewparams());
     m_configProject.preview_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     m_configProject.preview_showprofileinfo->setToolTip(i18n("Show default timeline preview parameters"));
     m_configProject.preview_manageprofile->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     m_configProject.preview_manageprofile->setToolTip(i18n("Manage timeline preview profiles"));
     m_configProject.kcfg_preview_profile->setToolTip(i18n("Select default timeline preview profile"));
 
     // proxy profile stuff
     m_configProxy.proxy_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     m_configProxy.proxy_showprofileinfo->setToolTip(i18n("Show default profile parameters"));
     m_configProxy.proxy_manageprofile->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     m_configProxy.proxy_manageprofile->setToolTip(i18n("Manage proxy profiles"));
     m_configProxy.kcfg_proxy_profile->setToolTip(i18n("Select default proxy profile"));
     m_configProxy.proxyparams->setVisible(false);
     m_configProxy.proxyparams->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 3);
     m_configProxy.proxyparams->setPlainText(KdenliveSettings::proxyparams());
 
     act = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure profiles"), this);
     act->setData(0);
     connect(act, &QAction::triggered, this, &KdenliveSettingsDialog::slotManageEncodingProfile);
     m_configProxy.proxy_manageprofile->setDefaultAction(act);
 
     connect(m_configProxy.proxy_showprofileinfo, &QAbstractButton::clicked, m_configProxy.proxyparams, &QWidget::setVisible);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configProxy.kcfg_proxy_profile, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-#else
-    connect(m_configProxy.kcfg_proxy_profile, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this,
-#endif
             &KdenliveSettingsDialog::slotUpdateProxyProfile);
 
     slotUpdateProxyProfile(-1);
     slotUpdateV4lProfile(-1);
     slotUpdateGrabProfile(-1);
     slotUpdateDecklinkProfile(-1);
 
     // enable GPU accel only if Movit is found
     m_configSdl.kcfg_gpu_accel->setEnabled(gpuAllowed);
     m_configSdl.kcfg_gpu_accel->setToolTip(i18n("GPU processing needs MLT compiled with Movit and Rtaudio modules"));
 
     getBlackMagicDeviceList(m_configCapture.kcfg_decklink_capturedevice);
     if (!getBlackMagicOutputDeviceList(m_configSdl.kcfg_blackmagic_output_device)) {
         // No blackmagic card found
         m_configSdl.kcfg_external_display->setEnabled(false);
     }
     
     initAudioRecDevice();
 
     // Config dialog size
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup settingsGroup(config, "settings");
     QSize optimalSize;
 
     if (!settingsGroup.exists() || !settingsGroup.hasKey("dialogSize")) {
         const QSize screenSize = (QGuiApplication::primaryScreen()->availableSize() * 0.9);
         const QSize targetSize = QSize(1024, 700);
         optimalSize = targetSize.boundedTo(screenSize);
     } else {
         optimalSize = settingsGroup.readEntry("dialogSize", QVariant(size())).toSize();
     }
     resize(optimalSize);
 }
 
 // static
 bool KdenliveSettingsDialog::getBlackMagicDeviceList(QComboBox *devicelist, bool force)
 {
     if (!force && !KdenliveSettings::decklink_device_found()) {
         return false;
     }
     Mlt::Profile profile;
     Mlt::Producer bm(profile, "decklink");
     int found_devices = 0;
     if (bm.is_valid()) {
         bm.set("list_devices", 1);
         found_devices = bm.get_int("devices");
     } else {
         KdenliveSettings::setDecklink_device_found(false);
     }
     if (found_devices <= 0) {
         devicelist->setEnabled(false);
         return false;
     }
     KdenliveSettings::setDecklink_device_found(true);
     for (int i = 0; i < found_devices; ++i) {
         char *tmp = qstrdup(QStringLiteral("device.%1").arg(i).toUtf8().constData());
         devicelist->addItem(bm.get(tmp));
         delete[] tmp;
     }
     return true;
 }
 
 // static
 bool KdenliveSettingsDialog::initAudioRecDevice()
 {
     QStringList audioDevices = pCore->getAudioCaptureDevices();
 
     //show a hint to the user to know what to check for in case the device list are empty (common issue)
     m_configCapture.labelNoAudioDevices->setVisible(audioDevices.empty());
 
     m_configCapture.kcfg_defaultaudiocapture->addItems(audioDevices);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_configCapture.kcfg_defaultaudiocapture, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), [&]() {
-#else
-    connect(m_configCapture.kcfg_defaultaudiocapture, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , [&]() {
-#endif
         QString currentDevice = m_configCapture.kcfg_defaultaudiocapture->currentText();
         KdenliveSettings::setDefaultaudiocapture(currentDevice);
     });
     QString selectedDevice = KdenliveSettings::defaultaudiocapture();
     int selectedIndex = m_configCapture.kcfg_defaultaudiocapture->findText(selectedDevice);
     if (!selectedDevice.isEmpty() && selectedIndex > -1) {
         m_configCapture.kcfg_defaultaudiocapture->setCurrentIndex(selectedIndex);
     }
     return true;
 }
 
 bool KdenliveSettingsDialog::getBlackMagicOutputDeviceList(QComboBox *devicelist, bool force)
 {
     if (!force && !KdenliveSettings::decklink_device_found()) {
         return false;
     }
     Mlt::Profile profile;
     Mlt::Consumer bm(profile, "decklink");
     int found_devices = 0;
     if (bm.is_valid()) {
         bm.set("list_devices", 1);
         found_devices = bm.get_int("devices");
     } else {
         KdenliveSettings::setDecklink_device_found(false);
     }
     if (found_devices <= 0) {
         devicelist->setEnabled(false);
         return false;
     }
     KdenliveSettings::setDecklink_device_found(true);
     for (int i = 0; i < found_devices; ++i) {
         char *tmp = qstrdup(QStringLiteral("device.%1").arg(i).toUtf8().constData());
         devicelist->addItem(bm.get(tmp));
         delete[] tmp;
     }
     devicelist->addItem(QStringLiteral("test"));
     return true;
 }
 
 void KdenliveSettingsDialog::setupJogshuttleBtns(const QString &device)
 {
     QList<QComboBox *> list;
     QList<QLabel *> list1;
 
     list << m_configShuttle.shuttle1;
     list << m_configShuttle.shuttle2;
     list << m_configShuttle.shuttle3;
     list << m_configShuttle.shuttle4;
     list << m_configShuttle.shuttle5;
     list << m_configShuttle.shuttle6;
     list << m_configShuttle.shuttle7;
     list << m_configShuttle.shuttle8;
     list << m_configShuttle.shuttle9;
     list << m_configShuttle.shuttle10;
     list << m_configShuttle.shuttle11;
     list << m_configShuttle.shuttle12;
     list << m_configShuttle.shuttle13;
     list << m_configShuttle.shuttle14;
     list << m_configShuttle.shuttle15;
 
     list1 << m_configShuttle.label_2;  // #1
     list1 << m_configShuttle.label_4;  // #2
     list1 << m_configShuttle.label_3;  // #3
     list1 << m_configShuttle.label_7;  // #4
     list1 << m_configShuttle.label_5;  // #5
     list1 << m_configShuttle.label_6;  // #6
     list1 << m_configShuttle.label_8;  // #7
     list1 << m_configShuttle.label_9;  // #8
     list1 << m_configShuttle.label_10; // #9
     list1 << m_configShuttle.label_11; // #10
     list1 << m_configShuttle.label_12; // #11
     list1 << m_configShuttle.label_13; // #12
     list1 << m_configShuttle.label_14; // #13
     list1 << m_configShuttle.label_15; // #14
     list1 << m_configShuttle.label_16; // #15
 
     for (int i = 0; i < list.count(); ++i) {
         list[i]->hide();
         list1[i]->hide();
     }
 #ifdef USE_JOGSHUTTLE
     if (!m_configShuttle.kcfg_enableshuttle->isChecked()) {
         return;
     }
     int keysCount = JogShuttle::keysCount(device);
 
     for (int i = 0; i < keysCount; ++i) {
         m_shuttle_buttons.push_back(list[i]);
         list[i]->show();
         list1[i]->show();
     }
 
     // populate the buttons with the current configuration. The items are sorted
     // according to the user-selected language, so they do not appear in random order.
     QMap<QString, QString> mappable_actions(m_mappable_actions);
     QList<QString> action_names = mappable_actions.keys();
     QList<QString>::Iterator iter = action_names.begin();
     // qCDebug(KDENLIVE_LOG) << "::::::::::::::::";
     while (iter != action_names.end()) {
         // qCDebug(KDENLIVE_LOG) << *iter;
         ++iter;
     }
 
     // qCDebug(KDENLIVE_LOG) << "::::::::::::::::";
 
     std::sort(action_names.begin(), action_names.end());
     iter = action_names.begin();
     while (iter != action_names.end()) {
         // qCDebug(KDENLIVE_LOG) << *iter;
         ++iter;
     }
     // qCDebug(KDENLIVE_LOG) << "::::::::::::::::";
 
     // Here we need to compute the action_id -> index-in-action_names. We iterate over the
     // action_names, as the sorting may depend on the user-language.
     QStringList actions_map = JogShuttleConfig::actionMap(KdenliveSettings::shuttlebuttons());
     QMap<QString, int> action_pos;
     for (const QString &action_id : actions_map) {
         // This loop find out at what index is the string that would map to the action_id.
         for (int i = 0; i < action_names.size(); ++i) {
             if (mappable_actions[action_names.at(i)] == action_id) {
                 action_pos[action_id] = i;
                 break;
             }
         }
     }
 
     int i = 0;
     for (QComboBox *button : m_shuttle_buttons) {
         button->addItems(action_names);
         connect(button, SIGNAL(activated(int)), this, SLOT(slotShuttleModified()));
         ++i;
         if (i < actions_map.size()) {
             button->setCurrentIndex(action_pos[actions_map[i]]);
         }
     }
 #else
     Q_UNUSED(device)
 #endif
 }
 
 KdenliveSettingsDialog::~KdenliveSettingsDialog() = default;
 
 void KdenliveSettingsDialog::slotUpdateGrabRegionStatus()
 {
     m_configCapture.region_group->setHidden(m_configCapture.kcfg_grab_capture_type->currentIndex() != 1);
 }
 
 void KdenliveSettingsDialog::slotEnableCaptureFolder()
 {
     m_configEnv.capturefolderurl->setEnabled(!m_configEnv.kcfg_capturetoprojectfolder->isChecked());
 }
 
 void KdenliveSettingsDialog::slotEnableLibraryFolder()
 {
     m_configEnv.libraryfolderurl->setEnabled(!m_configEnv.kcfg_librarytodefaultfolder->isChecked());
 }
 
 void KdenliveSettingsDialog::initDevices()
 {
     // Fill audio drivers
     m_configSdl.kcfg_audio_driver->addItem(i18n("Automatic"), QString());
 #if defined(Q_OS_WIN)
     //TODO: i18n
     m_configSdl.kcfg_audio_driver->addItem("DirectSound", "directsound");
     m_configSdl.kcfg_audio_driver->addItem("WinMM", "winmm");
     m_configSdl.kcfg_audio_driver->addItem("Wasapi", "wasapi");
 #elif !defined(Q_WS_MAC)
     m_configSdl.kcfg_audio_driver->addItem(i18n("ALSA"), "alsa");
     m_configSdl.kcfg_audio_driver->addItem(i18n("PulseAudio"), "pulseaudio");
     m_configSdl.kcfg_audio_driver->addItem(i18n("OSS"), "dsp");
     //m_configSdl.kcfg_audio_driver->addItem(i18n("OSS with DMA access"), "dma");
     m_configSdl.kcfg_audio_driver->addItem(i18n("Esound daemon"), "esd");
     m_configSdl.kcfg_audio_driver->addItem(i18n("ARTS daemon"), "artsc");
 #endif
 
     if (!KdenliveSettings::audiodrivername().isEmpty())
         for (int i = 1; i < m_configSdl.kcfg_audio_driver->count(); ++i) {
             if (m_configSdl.kcfg_audio_driver->itemData(i).toString() == KdenliveSettings::audiodrivername()) {
                 m_configSdl.kcfg_audio_driver->setCurrentIndex(i);
                 KdenliveSettings::setAudio_driver((uint)i);
             }
         }
 
     // Fill the list of audio playback / recording devices
     m_configSdl.kcfg_audio_device->addItem(i18n("Default"), QString());
     m_configCapture.kcfg_v4l_alsadevice->addItem(i18n("Default"), "default");
     if (!QStandardPaths::findExecutable(QStringLiteral("aplay")).isEmpty()) {
         m_readProcess.setOutputChannelMode(KProcess::OnlyStdoutChannel);
         m_readProcess.setProgram(QStringLiteral("aplay"), QStringList() << QStringLiteral("-l"));
         connect(&m_readProcess, &KProcess::readyReadStandardOutput, this, &KdenliveSettingsDialog::slotReadAudioDevices);
         m_readProcess.execute(5000);
     } else {
         // If aplay is not installed on the system, parse the /proc/asound/pcm file
         QFile file(QStringLiteral("/proc/asound/pcm"));
         if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
             QTextStream stream(&file);
             QString line = stream.readLine();
             QString deviceId;
             while (!line.isNull()) {
                 if (line.contains(QStringLiteral("playback"))) {
                     deviceId = line.section(QLatin1Char(':'), 0, 0);
                     m_configSdl.kcfg_audio_device->addItem(line.section(QLatin1Char(':'), 1, 1), QStringLiteral("plughw:%1,%2")
                                                                                                      .arg(deviceId.section(QLatin1Char('-'), 0, 0).toInt())
                                                                                                      .arg(deviceId.section(QLatin1Char('-'), 1, 1).toInt()));
                 }
                 if (line.contains(QStringLiteral("capture"))) {
                     deviceId = line.section(QLatin1Char(':'), 0, 0);
                     m_configCapture.kcfg_v4l_alsadevice->addItem(
                         line.section(QLatin1Char(':'), 1, 1).simplified(),
                         QStringLiteral("hw:%1,%2").arg(deviceId.section(QLatin1Char('-'), 0, 0).toInt()).arg(deviceId.section(QLatin1Char('-'), 1, 1).toInt()));
                 }
                 line = stream.readLine();
             }
             file.close();
         } else {
             qCDebug(KDENLIVE_LOG) << " / / / /CANNOT READ PCM";
         }
     }
 
     // Add pulseaudio capture option
     m_configCapture.kcfg_v4l_alsadevice->addItem(i18n("PulseAudio"), "pulse");
 
     if (!KdenliveSettings::audiodevicename().isEmpty()) {
         // Select correct alsa device
         int ix = m_configSdl.kcfg_audio_device->findData(KdenliveSettings::audiodevicename());
         m_configSdl.kcfg_audio_device->setCurrentIndex(ix);
         KdenliveSettings::setAudio_device(ix);
     }
 
     if (!KdenliveSettings::v4l_alsadevicename().isEmpty()) {
         // Select correct alsa device
         int ix = m_configCapture.kcfg_v4l_alsadevice->findData(KdenliveSettings::v4l_alsadevicename());
         m_configCapture.kcfg_v4l_alsadevice->setCurrentIndex(ix);
         KdenliveSettings::setV4l_alsadevice(ix);
     }
 
     m_configSdl.kcfg_audio_backend->addItem(i18n("SDL"), KdenliveSettings::sdlAudioBackend());
     m_configSdl.kcfg_audio_backend->addItem(i18n("RtAudio"), "rtaudio");
 
     if (!KdenliveSettings::audiobackend().isEmpty()) {
         int ix = m_configSdl.kcfg_audio_backend->findData(KdenliveSettings::audiobackend());
         m_configSdl.kcfg_audio_backend->setCurrentIndex(ix);
         KdenliveSettings::setAudio_backend(ix);
     }
     m_configSdl.group_sdl->setEnabled(KdenliveSettings::audiobackend().startsWith(QLatin1String("sdl")));
 
     loadCurrentV4lProfileInfo();
 }
 
 void KdenliveSettingsDialog::slotReadAudioDevices()
 {
     QString result = QString(m_readProcess.readAllStandardOutput());
     // qCDebug(KDENLIVE_LOG) << "// / / / / / READING APLAY: ";
     // qCDebug(KDENLIVE_LOG) << result;
     const QStringList lines = result.split(QLatin1Char('\n'));
     for (const QString &devicestr : lines) {
         ////qCDebug(KDENLIVE_LOG) << "// READING LINE: " << data;
         if (!devicestr.startsWith(QLatin1Char(' ')) && devicestr.count(QLatin1Char(':')) > 1) {
             QString card = devicestr.section(QLatin1Char(':'), 0, 0).section(QLatin1Char(' '), -1);
             QString device = devicestr.section(QLatin1Char(':'), 1, 1).section(QLatin1Char(' '), -1);
             m_configSdl.kcfg_audio_device->addItem(devicestr.section(QLatin1Char(':'), -1).simplified(), QStringLiteral("plughw:%1,%2").arg(card).arg(device));
             m_configCapture.kcfg_v4l_alsadevice->addItem(devicestr.section(QLatin1Char(':'), -1).simplified(),
                                                          QStringLiteral("hw:%1,%2").arg(card).arg(device));
         }
     }
 }
 
 void KdenliveSettingsDialog::showPage(int page, int option)
 {
     switch (page) {
     case 1:
         setCurrentPage(m_page1);
         break;
     case 2:
         setCurrentPage(m_page2);
         break;
     case 3:
         setCurrentPage(m_page3);
         break;
     case 4:
         setCurrentPage(m_page4);
         m_configCapture.tabWidget->setCurrentIndex(option);
         break;
     case 5:
         setCurrentPage(m_page5);
         break;
     case 6:
         setCurrentPage(m_page6);
         break;
     case 7:
         setCurrentPage(m_page7);
         break;
     default:
         setCurrentPage(m_page1);
     }
 }
 
 void KdenliveSettingsDialog::slotEditAudioApplication()
 {
     KService::Ptr service;
     QPointer<KOpenWithDialog> dlg = new KOpenWithDialog(QList<QUrl>(), i18n("Select default audio editor"), m_configEnv.kcfg_defaultaudioapp->text(), this);
     if (dlg->exec() == QDialog::Accepted) {
         service = dlg->service();
         m_configEnv.kcfg_defaultaudioapp->setText(KIO::DesktopExecParser::executablePath(service->exec()));
     }
 
     delete dlg;
 }
 
 void KdenliveSettingsDialog::slotEditImageApplication()
 {
     QPointer<KOpenWithDialog> dlg = new KOpenWithDialog(QList<QUrl>(), i18n("Select default image editor"), m_configEnv.kcfg_defaultimageapp->text(), this);
     if (dlg->exec() == QDialog::Accepted) {
         KService::Ptr service = dlg->service();
         m_configEnv.kcfg_defaultimageapp->setText(KIO::DesktopExecParser::executablePath(service->exec()));
     }
     delete dlg;
 }
 
 void KdenliveSettingsDialog::slotCheckShuttle(int state)
 {
 #ifdef USE_JOGSHUTTLE
     m_configShuttle.config_group->setEnabled(state != 0);
     m_configShuttle.shuttledevicelist->clear();
 
     QStringList devNames = KdenliveSettings::shuttledevicenames();
     QStringList devPaths = KdenliveSettings::shuttledevicepaths();
 
     if (devNames.count() != devPaths.count()) {
         return;
     }
     for (int i = 0; i < devNames.count(); ++i) {
         m_configShuttle.shuttledevicelist->addItem(devNames.at(i), devPaths.at(i));
     }
     if (state != 0) {
         setupJogshuttleBtns(m_configShuttle.shuttledevicelist->itemData(m_configShuttle.shuttledevicelist->currentIndex()).toString());
     }
 #else
     Q_UNUSED(state)
 #endif /* USE_JOGSHUTTLE */
 }
 
 void KdenliveSettingsDialog::slotUpdateShuttleDevice(int ix)
 {
 #ifdef USE_JOGSHUTTLE
     QString device = m_configShuttle.shuttledevicelist->itemData(ix).toString();
     // KdenliveSettings::setShuttledevice(device);
     setupJogshuttleBtns(device);
     m_configShuttle.kcfg_shuttledevice->setText(device);
 #else
     Q_UNUSED(ix)
 #endif /* USE_JOGSHUTTLE */
 }
 
 void KdenliveSettingsDialog::updateWidgets()
 {
 // Revert widgets to last saved state (for example when user pressed "Cancel")
 // //qCDebug(KDENLIVE_LOG) << "// // // KCONFIG Revert called";
 #ifdef USE_JOGSHUTTLE
     // revert jog shuttle device
     if (m_configShuttle.shuttledevicelist->count() > 0) {
         for (int i = 0; i < m_configShuttle.shuttledevicelist->count(); ++i) {
             if (m_configShuttle.shuttledevicelist->itemData(i) == KdenliveSettings::shuttledevice()) {
                 m_configShuttle.shuttledevicelist->setCurrentIndex(i);
                 break;
             }
         }
     }
 
     // Revert jog shuttle buttons
     QList<QString> action_names = m_mappable_actions.keys();
     std::sort(action_names.begin(), action_names.end());
     QStringList actions_map = JogShuttleConfig::actionMap(KdenliveSettings::shuttlebuttons());
     QMap<QString, int> action_pos;
     for (const QString &action_id : actions_map) {
         // This loop find out at what index is the string that would map to the action_id.
         for (int i = 0; i < action_names.size(); ++i) {
             if (m_mappable_actions[action_names[i]] == action_id) {
                 action_pos[action_id] = i;
                 break;
             }
         }
     }
     int i = 0;
     for (QComboBox *button : m_shuttle_buttons) {
         ++i;
         if (i < actions_map.size()) {
             button->setCurrentIndex(action_pos[actions_map[i]]);
         }
     }
 #endif /* USE_JOGSHUTTLE */
 }
 
 void KdenliveSettingsDialog::accept()
 {
     if (m_pw->selectedProfile().isEmpty()) {
         KMessageBox::error(this, i18n("Please select a video profile"));
         return;
     }
     KConfigDialog::accept();
 }
 
 void KdenliveSettingsDialog::updateSettings()
 {
     // Save changes to settings (for example when user pressed "Apply" or "Ok")
     // //qCDebug(KDENLIVE_LOG) << "// // // KCONFIG UPDATE called";
     if (m_pw->selectedProfile().isEmpty()) {
         KMessageBox::error(this, i18n("Please select a video profile"));
         return;
     }
     KdenliveSettings::setDefault_profile(m_pw->selectedProfile());
 
     bool resetProfile = false;
     bool resetConsumer = false;
     bool fullReset = false;
     bool updateCapturePath = false;
     bool updateLibrary = false;
 
     /*if (m_configShuttle.shuttledevicelist->count() > 0) {
     QString device = m_configShuttle.shuttledevicelist->itemData(m_configShuttle.shuttledevicelist->currentIndex()).toString();
     if (device != KdenliveSettings::shuttledevice()) KdenliveSettings::setShuttledevice(device);
     }*/
 
     // Capture default folder
     if (m_configEnv.kcfg_capturetoprojectfolder->isChecked() != KdenliveSettings::capturetoprojectfolder()) {
         KdenliveSettings::setCapturetoprojectfolder(m_configEnv.kcfg_capturetoprojectfolder->isChecked());
         updateCapturePath = true;
     }
 
     if (m_configProject.projecturl->url().toLocalFile() != KdenliveSettings::defaultprojectfolder()) {
         KdenliveSettings::setDefaultprojectfolder(m_configProject.projecturl->url().toLocalFile());
     }
 
     if (m_configEnv.capturefolderurl->url().toLocalFile() != KdenliveSettings::capturefolder()) {
         KdenliveSettings::setCapturefolder(m_configEnv.capturefolderurl->url().toLocalFile());
         updateCapturePath = true;
     }
 
     // Library default folder
     if (m_configEnv.kcfg_librarytodefaultfolder->isChecked() != KdenliveSettings::librarytodefaultfolder()) {
         KdenliveSettings::setLibrarytodefaultfolder(m_configEnv.kcfg_librarytodefaultfolder->isChecked());
         updateLibrary = true;
     }
 
     if (m_configEnv.libraryfolderurl->url().toLocalFile() != KdenliveSettings::libraryfolder()) {
         KdenliveSettings::setLibraryfolder(m_configEnv.libraryfolderurl->url().toLocalFile());
         if (!KdenliveSettings::librarytodefaultfolder()) {
             updateLibrary = true;
         }
     }
 
     if (m_configCapture.kcfg_v4l_format->currentIndex() != (int)KdenliveSettings::v4l_format()) {
         saveCurrentV4lProfile();
         KdenliveSettings::setV4l_format(0);
     }
 
     // Check if screengrab is fullscreen
     if (m_configCapture.kcfg_grab_capture_type->currentIndex() != KdenliveSettings::grab_capture_type()) {
         KdenliveSettings::setGrab_capture_type(m_configCapture.kcfg_grab_capture_type->currentIndex());
         emit updateFullScreenGrab();
     }
 
     // Check encoding profiles
     // FFmpeg
     QString profilestr = m_configCapture.kcfg_v4l_profile->currentData().toString();
     if (!profilestr.isEmpty() && (profilestr.section(QLatin1Char(';'), 0, 0) != KdenliveSettings::v4l_parameters() ||
                                   profilestr.section(QLatin1Char(';'), 1, 1) != KdenliveSettings::v4l_extension())) {
         KdenliveSettings::setV4l_parameters(profilestr.section(QLatin1Char(';'), 0, 0));
         KdenliveSettings::setV4l_extension(profilestr.section(QLatin1Char(';'), 1, 1));
     }
     // screengrab
     profilestr = m_configCapture.kcfg_grab_profile->currentData().toString();
     if (!profilestr.isEmpty() && (profilestr.section(QLatin1Char(';'), 0, 0) != KdenliveSettings::grab_parameters() ||
                                   profilestr.section(QLatin1Char(';'), 1, 1) != KdenliveSettings::grab_extension())) {
         KdenliveSettings::setGrab_parameters(profilestr.section(QLatin1Char(';'), 0, 0));
         KdenliveSettings::setGrab_extension(profilestr.section(QLatin1Char(';'), 1, 1));
     }
 
     // decklink
     profilestr = m_configCapture.kcfg_decklink_profile->currentData().toString();
     if (!profilestr.isEmpty() && (profilestr.section(QLatin1Char(';'), 0, 0) != KdenliveSettings::decklink_parameters() ||
                                   profilestr.section(QLatin1Char(';'), 1, 1) != KdenliveSettings::decklink_extension())) {
         KdenliveSettings::setDecklink_parameters(profilestr.section(QLatin1Char(';'), 0, 0));
         KdenliveSettings::setDecklink_extension(profilestr.section(QLatin1Char(';'), 1, 1));
     }
     // proxies
     profilestr = m_configProxy.kcfg_proxy_profile->currentData().toString();
     if (!profilestr.isEmpty() && (profilestr.section(QLatin1Char(';'), 0, 0) != KdenliveSettings::proxyparams() ||
                                   profilestr.section(QLatin1Char(';'), 1, 1) != KdenliveSettings::proxyextension())) {
         KdenliveSettings::setProxyparams(profilestr.section(QLatin1Char(';'), 0, 0));
         KdenliveSettings::setProxyextension(profilestr.section(QLatin1Char(';'), 1, 1));
     }
 
     // external proxies
     profilestr = m_configProxy.kcfg_external_proxy_profile->currentData().toString();
     if (!profilestr.isEmpty() && (profilestr != KdenliveSettings::externalProxyProfile())) {
         KdenliveSettings::setExternalProxyProfile(profilestr);
     }
 
     // timeline preview
     profilestr = m_configProject.kcfg_preview_profile->currentData().toString();
     if (!profilestr.isEmpty() && (profilestr.section(QLatin1Char(';'), 0, 0) != KdenliveSettings::previewparams() ||
                                   profilestr.section(QLatin1Char(';'), 1, 1) != KdenliveSettings::previewextension())) {
         KdenliveSettings::setPreviewparams(profilestr.section(QLatin1Char(';'), 0, 0));
         KdenliveSettings::setPreviewextension(profilestr.section(QLatin1Char(';'), 1, 1));
     }
 
     if (updateCapturePath) {
         emit updateCaptureFolder();
     }
     if (updateLibrary) {
         emit updateLibraryFolder();
     }
 
     QString value = m_configCapture.kcfg_v4l_alsadevice->currentData().toString();
     if (value != KdenliveSettings::v4l_alsadevicename()) {
         KdenliveSettings::setV4l_alsadevicename(value);
     }
 
     if (m_configSdl.kcfg_external_display->isChecked() != KdenliveSettings::external_display()) {
         KdenliveSettings::setExternal_display(m_configSdl.kcfg_external_display->isChecked());
         resetConsumer = true;
         fullReset = true;
     } else if (KdenliveSettings::external_display() &&
                KdenliveSettings::blackmagic_output_device() != m_configSdl.kcfg_blackmagic_output_device->currentIndex()) {
         resetConsumer = true;
         fullReset = true;
     }
 
     value = m_configSdl.kcfg_audio_driver->currentData().toString();
     if (value != KdenliveSettings::audiodrivername()) {
         KdenliveSettings::setAudiodrivername(value);
         resetConsumer = true;
     }
 
     if (value == QLatin1String("alsa")) {
         // Audio device setting is only valid for alsa driver
         value = m_configSdl.kcfg_audio_device->currentData().toString();
         if (value != KdenliveSettings::audiodevicename()) {
             KdenliveSettings::setAudiodevicename(value);
             resetConsumer = true;
         }
     } else if (!KdenliveSettings::audiodevicename().isEmpty()) {
         KdenliveSettings::setAudiodevicename(QString());
         resetConsumer = true;
     }
 
     value = m_configSdl.kcfg_audio_backend->currentData().toString();
     if (value != KdenliveSettings::audiobackend()) {
         KdenliveSettings::setAudiobackend(value);
         resetConsumer = true;
         fullReset = true;
     }
 
     if (m_configSdl.kcfg_window_background->color() != KdenliveSettings::window_background()) {
         KdenliveSettings::setWindow_background(m_configSdl.kcfg_window_background->color());
         emit updateMonitorBg();
         resetProfile = true;
     }
 
     if (m_configSdl.kcfg_volume->value() != KdenliveSettings::volume()) {
         KdenliveSettings::setVolume(m_configSdl.kcfg_volume->value());
         resetConsumer = true;
     }
 
     if (m_configMisc.kcfg_tabposition->currentIndex() != KdenliveSettings::tabposition()) {
         KdenliveSettings::setTabposition(m_configMisc.kcfg_tabposition->currentIndex());
     }
 
     if (m_configTimeline.kcfg_displayallchannels->isChecked() != KdenliveSettings::displayallchannels()) {
         KdenliveSettings::setDisplayallchannels(m_configTimeline.kcfg_displayallchannels->isChecked());
         emit audioThumbFormatChanged();
     }
 
     if (m_modified) {
         // The transcoding profiles were modified, save.
         m_modified = false;
         saveTranscodeProfiles();
     }
 
 #ifdef USE_JOGSHUTTLE
     m_shuttleModified = false;
 
     QStringList actions;
     actions << QStringLiteral("monitor_pause"); // the Job rest position action.
     for (QComboBox *button : m_shuttle_buttons) {
         actions << m_mappable_actions[button->currentText()];
     }
     QString maps = JogShuttleConfig::actionMap(actions);
     // fprintf(stderr, "Shuttle config: %s\n", JogShuttleConfig::actionMap(actions).toLatin1().constData());
     if (KdenliveSettings::shuttlebuttons() != maps) {
         KdenliveSettings::setShuttlebuttons(maps);
     }
 #endif
 
     bool restart = false;
     if (m_configSdl.kcfg_gpu_accel->isChecked() != KdenliveSettings::gpu_accel()) {
         // GPU setting was changed, we need to restart Kdenlive or everything will be corrupted
         if (KMessageBox::warningContinueCancel(this, i18n("Kdenlive must be restarted to change this setting")) == KMessageBox::Continue) {
             restart = true;
         } else {
             m_configSdl.kcfg_gpu_accel->setChecked(KdenliveSettings::gpu_accel());
         }
     }
 
     if (m_configTimeline.kcfg_trackheight->value() != KdenliveSettings::trackheight()) {
         KdenliveSettings::setTrackheight(m_configTimeline.kcfg_trackheight->value());
         emit resetView();
     }
 
     if (m_configTimeline.kcfg_autoscroll->isChecked() != KdenliveSettings::autoscroll()) {
         KdenliveSettings::setAutoscroll(m_configTimeline.kcfg_autoscroll->isChecked());
         pCore->autoScrollChanged();
     }
 
     // Mimes
     if (m_configEnv.kcfg_addedExtensions->text() != KdenliveSettings::addedExtensions()) {
         // Update list
         KdenliveSettings::setAddedExtensions(m_configEnv.kcfg_addedExtensions->text());
         QStringList mimes = ClipCreationDialog::getExtensions();
         std::sort(mimes.begin(), mimes.end());
         m_configEnv.supportedmimes->setPlainText(mimes.join(QLatin1Char(' ')));
     }
 
     KConfigDialog::settingsChangedSlot();
     // KConfigDialog::updateSettings();
     if (resetConsumer) {
         emit doResetConsumer(fullReset);
     }
     if (resetProfile) {
         emit doResetProfile();
     }
     if (restart) {
         emit restartKdenlive();
     }
     emit checkTabPosition();
 
     // remembering Config dialog size
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup settingsGroup(config, "settings");
     settingsGroup.writeEntry("dialogSize", QVariant(size()));
 }
 
 void KdenliveSettingsDialog::slotCheckAlsaDriver()
 {
     QString value = m_configSdl.kcfg_audio_driver->itemData(m_configSdl.kcfg_audio_driver->currentIndex()).toString();
     m_configSdl.kcfg_audio_device->setEnabled(value == QLatin1String("alsa"));
 }
 
 void KdenliveSettingsDialog::slotCheckAudioBackend()
 {
     QString value = m_configSdl.kcfg_audio_backend->itemData(m_configSdl.kcfg_audio_backend->currentIndex()).toString();
     m_configSdl.group_sdl->setEnabled(value.startsWith(QLatin1String("sdl")));
 }
 
 void KdenliveSettingsDialog::loadTranscodeProfiles()
 {
     KSharedConfigPtr config =
         KSharedConfig::openConfig(QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("kdenlivetranscodingrc")), KConfig::CascadeConfig);
     KConfigGroup transConfig(config, "Transcoding");
     // read the entries
     m_configTranscode.profiles_list->blockSignals(true);
     m_configTranscode.profiles_list->clear();
     QMap<QString, QString> profiles = transConfig.entryMap();
     QMapIterator<QString, QString> i(profiles);
     while (i.hasNext()) {
         i.next();
         auto *item = new QListWidgetItem(i.key());
         QString profilestr = i.value();
         if (profilestr.contains(QLatin1Char(';'))) {
             item->setToolTip(profilestr.section(QLatin1Char(';'), 1, 1));
         }
         item->setData(Qt::UserRole, profilestr);
         m_configTranscode.profiles_list->addItem(item);
         // item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
     }
     m_configTranscode.profiles_list->blockSignals(false);
     m_configTranscode.profiles_list->setCurrentRow(0);
 }
 
 void KdenliveSettingsDialog::saveTranscodeProfiles()
 {
     QString transcodeFile = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/kdenlivetranscodingrc");
     KSharedConfigPtr config = KSharedConfig::openConfig(transcodeFile);
     KConfigGroup transConfig(config, "Transcoding");
     // read the entries
     transConfig.deleteGroup();
     int max = m_configTranscode.profiles_list->count();
     for (int i = 0; i < max; ++i) {
         QListWidgetItem *item = m_configTranscode.profiles_list->item(i);
         transConfig.writeEntry(item->text(), item->data(Qt::UserRole).toString());
     }
     config->sync();
 }
 
 void KdenliveSettingsDialog::slotAddTranscode()
 {
     if (!m_configTranscode.profiles_list->findItems(m_configTranscode.profile_name->text(), Qt::MatchExactly).isEmpty()) {
         KMessageBox::sorry(this, i18n("A profile with that name already exists"));
         return;
     }
     QListWidgetItem *item = new QListWidgetItem(m_configTranscode.profile_name->text());
     QString profilestr = m_configTranscode.profile_parameters->toPlainText();
     profilestr.append(" %1." + m_configTranscode.profile_extension->text());
     profilestr.append(';');
     if (!m_configTranscode.profile_description->text().isEmpty()) {
         profilestr.append(m_configTranscode.profile_description->text());
     }
     if (m_configTranscode.profile_audioonly->isChecked()) {
         profilestr.append(";audio");
     }
     item->setData(Qt::UserRole, profilestr);
     m_configTranscode.profiles_list->addItem(item);
     m_configTranscode.profiles_list->setCurrentItem(item);
     slotDialogModified();
 }
 
 void KdenliveSettingsDialog::slotUpdateTranscodingProfile()
 {
     QListWidgetItem *item = m_configTranscode.profiles_list->currentItem();
     if (!item) {
         return;
     }
     m_configTranscode.button_update->setEnabled(false);
     item->setText(m_configTranscode.profile_name->text());
     QString profilestr = m_configTranscode.profile_parameters->toPlainText();
     profilestr.append(" %1." + m_configTranscode.profile_extension->text());
     profilestr.append(';');
     if (!m_configTranscode.profile_description->text().isEmpty()) {
         profilestr.append(m_configTranscode.profile_description->text());
     }
     if (m_configTranscode.profile_audioonly->isChecked()) {
         profilestr.append(QStringLiteral(";audio"));
     }
     item->setData(Qt::UserRole, profilestr);
     slotDialogModified();
 }
 
 void KdenliveSettingsDialog::slotDeleteTranscode()
 {
     QListWidgetItem *item = m_configTranscode.profiles_list->currentItem();
     if (item == nullptr) {
         return;
     }
     delete item;
     slotDialogModified();
 }
 
 void KdenliveSettingsDialog::slotEnableTranscodeUpdate()
 {
     if (!m_configTranscode.profile_box->isEnabled()) {
         return;
     }
     bool allow = true;
     if (m_configTranscode.profile_name->text().isEmpty() || m_configTranscode.profile_extension->text().isEmpty()) {
         allow = false;
     }
     m_configTranscode.button_update->setEnabled(allow);
 }
 
 void KdenliveSettingsDialog::slotSetTranscodeProfile()
 {
     m_configTranscode.profile_box->setEnabled(false);
     m_configTranscode.button_update->setEnabled(false);
     m_configTranscode.profile_name->clear();
     m_configTranscode.profile_description->clear();
     m_configTranscode.profile_extension->clear();
     m_configTranscode.profile_parameters->clear();
     m_configTranscode.profile_audioonly->setChecked(false);
     QListWidgetItem *item = m_configTranscode.profiles_list->currentItem();
     if (!item) {
         return;
     }
     m_configTranscode.profile_name->setText(item->text());
     QString profilestr = item->data(Qt::UserRole).toString();
     if (profilestr.contains(QLatin1Char(';'))) {
         m_configTranscode.profile_description->setText(profilestr.section(QLatin1Char(';'), 1, 1));
         if (profilestr.section(QLatin1Char(';'), 2, 2) == QLatin1String("audio")) {
             m_configTranscode.profile_audioonly->setChecked(true);
         }
         profilestr = profilestr.section(QLatin1Char(';'), 0, 0).simplified();
     }
     m_configTranscode.profile_extension->setText(profilestr.section(QLatin1Char('.'), -1));
     m_configTranscode.profile_parameters->setPlainText(profilestr.section(QLatin1Char(' '), 0, -2));
     m_configTranscode.profile_box->setEnabled(true);
 }
 
 void KdenliveSettingsDialog::slotShuttleModified()
 {
 #ifdef USE_JOGSHUTTLE
     QStringList actions;
     actions << QStringLiteral("monitor_pause"); // the Job rest position action.
     for (QComboBox *button : m_shuttle_buttons) {
         actions << m_mappable_actions[button->currentText()];
     }
     QString maps = JogShuttleConfig::actionMap(actions);
     m_shuttleModified = KdenliveSettings::shuttlebuttons() != maps;
 #endif
     KConfigDialog::updateButtons();
 }
 
 void KdenliveSettingsDialog::slotDialogModified()
 {
     m_modified = true;
     KConfigDialog::updateButtons();
 }
 
 // virtual
 bool KdenliveSettingsDialog::hasChanged()
 {
     if (m_modified || m_shuttleModified) {
         return true;
     }
     return KConfigDialog::hasChanged();
 }
 
 void KdenliveSettingsDialog::slotUpdatev4lDevice()
 {
     QString device = m_configCapture.kcfg_detectedv4ldevices->itemData(m_configCapture.kcfg_detectedv4ldevices->currentIndex()).toString();
     if (!device.isEmpty()) {
         m_configCapture.kcfg_video4vdevice->setText(device);
     }
     QString info = m_configCapture.kcfg_detectedv4ldevices->itemData(m_configCapture.kcfg_detectedv4ldevices->currentIndex(), Qt::UserRole + 1).toString();
 
     m_configCapture.kcfg_v4l_format->blockSignals(true);
     m_configCapture.kcfg_v4l_format->clear();
 
     QString vl4ProfilePath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/profiles/video4linux");
     if (QFile::exists(vl4ProfilePath)) {
         m_configCapture.kcfg_v4l_format->addItem(i18n("Current settings"));
     }
 
     QStringList pixelformats = info.split('>', QString::SkipEmptyParts);
     QString itemSize;
     QString pixelFormat;
     QStringList itemRates;
     for (int i = 0; i < pixelformats.count(); ++i) {
         QString format = pixelformats.at(i).section(QLatin1Char(':'), 0, 0);
         QStringList sizes = pixelformats.at(i).split(':', QString::SkipEmptyParts);
         pixelFormat = sizes.takeFirst();
         for (int j = 0; j < sizes.count(); ++j) {
             itemSize = sizes.at(j).section(QLatin1Char('='), 0, 0);
             itemRates = sizes.at(j).section(QLatin1Char('='), 1, 1).split(QLatin1Char(','), QString::SkipEmptyParts);
             for (int k = 0; k < itemRates.count(); ++k) {
                 m_configCapture.kcfg_v4l_format->addItem(
                     QLatin1Char('[') + format + QStringLiteral("] ") + itemSize + QStringLiteral(" (") + itemRates.at(k) + QLatin1Char(')'),
                     QStringList() << format << itemSize.section('x', 0, 0) << itemSize.section('x', 1, 1) << itemRates.at(k).section(QLatin1Char('/'), 0, 0)
                                   << itemRates.at(k).section(QLatin1Char('/'), 1, 1));
             }
         }
     }
     m_configCapture.kcfg_v4l_format->blockSignals(false);
     slotUpdatev4lCaptureProfile();
 }
 
 void KdenliveSettingsDialog::slotUpdatev4lCaptureProfile()
 {
     QStringList info = m_configCapture.kcfg_v4l_format->itemData(m_configCapture.kcfg_v4l_format->currentIndex(), Qt::UserRole).toStringList();
     if (info.isEmpty()) {
         // No auto info, display the current ones
         loadCurrentV4lProfileInfo();
         return;
     }
     m_configCapture.p_size->setText(info.at(1) + QLatin1Char('x') + info.at(2));
     m_configCapture.p_fps->setText(info.at(3) + QLatin1Char('/') + info.at(4));
     m_configCapture.p_aspect->setText(QStringLiteral("1/1"));
     m_configCapture.p_display->setText(info.at(1) + QLatin1Char('/') + info.at(2));
     m_configCapture.p_colorspace->setText(ProfileRepository::getColorspaceDescription(601));
     m_configCapture.p_progressive->setText(i18n("Progressive"));
 
     QDir dir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/profiles/"));
     if (!dir.exists() || !dir.exists(QStringLiteral("video4linux"))) {
         saveCurrentV4lProfile();
     }
 }
 
 void KdenliveSettingsDialog::loadCurrentV4lProfileInfo()
 {
     QDir dir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/profiles/"));
     if (!dir.exists()) {
         dir.mkpath(QStringLiteral("."));
     }
     if (!ProfileRepository::get()->profileExists(dir.absoluteFilePath(QStringLiteral("video4linux")))) {
         // No default formats found, build one
         std::unique_ptr<ProfileParam> prof(new ProfileParam(pCore->getCurrentProfile().get()));
         prof->m_width = 320;
         prof->m_height = 200;
         prof->m_frame_rate_num = 15;
         prof->m_frame_rate_den = 1;
         prof->m_display_aspect_num = 4;
         prof->m_display_aspect_den = 3;
         prof->m_sample_aspect_num = 1;
         prof->m_sample_aspect_den = 1;
         prof->m_progressive = true;
         prof->m_colorspace = 601;
         ProfileRepository::get()->saveProfile(prof.get(), dir.absoluteFilePath(QStringLiteral("video4linux")));
     }
     auto &prof = ProfileRepository::get()->getProfile(dir.absoluteFilePath(QStringLiteral("video4linux")));
     m_configCapture.p_size->setText(QString::number(prof->width()) + QLatin1Char('x') + QString::number(prof->height()));
     m_configCapture.p_fps->setText(QString::number(prof->frame_rate_num()) + QLatin1Char('/') + QString::number(prof->frame_rate_den()));
     m_configCapture.p_aspect->setText(QString::number(prof->sample_aspect_num()) + QLatin1Char('/') + QString::number(prof->sample_aspect_den()));
     m_configCapture.p_display->setText(QString::number(prof->display_aspect_num()) + QLatin1Char('/') + QString::number(prof->display_aspect_den()));
     m_configCapture.p_colorspace->setText(ProfileRepository::getColorspaceDescription(prof->colorspace()));
     if (prof->progressive()) {
         m_configCapture.p_progressive->setText(i18n("Progressive"));
     }
 }
 
 void KdenliveSettingsDialog::saveCurrentV4lProfile()
 {
     std::unique_ptr<ProfileParam> profile(new ProfileParam(pCore->getCurrentProfile().get()));
     profile->m_description = QStringLiteral("Video4Linux capture");
     profile->m_colorspace = ProfileRepository::getColorspaceFromDescription(m_configCapture.p_colorspace->text());
     profile->m_width = m_configCapture.p_size->text().section('x', 0, 0).toInt();
     profile->m_height = m_configCapture.p_size->text().section('x', 1, 1).toInt();
     profile->m_sample_aspect_num = m_configCapture.p_aspect->text().section(QLatin1Char('/'), 0, 0).toInt();
     profile->m_sample_aspect_den = m_configCapture.p_aspect->text().section(QLatin1Char('/'), 1, 1).toInt();
     profile->m_display_aspect_num = m_configCapture.p_display->text().section(QLatin1Char('/'), 0, 0).toInt();
     profile->m_display_aspect_den = m_configCapture.p_display->text().section(QLatin1Char('/'), 1, 1).toInt();
     profile->m_frame_rate_num = m_configCapture.p_fps->text().section(QLatin1Char('/'), 0, 0).toInt();
     profile->m_frame_rate_den = m_configCapture.p_fps->text().section(QLatin1Char('/'), 1, 1).toInt();
     profile->m_progressive = m_configCapture.p_progressive->text() == i18n("Progressive");
     QDir dir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/profiles/"));
     if (!dir.exists()) {
         dir.mkpath(QStringLiteral("."));
     }
     ProfileRepository::get()->saveProfile(profile.get(), dir.absoluteFilePath(QStringLiteral("video4linux")));
 }
 
 void KdenliveSettingsDialog::slotManageEncodingProfile()
 {
     auto *act = qobject_cast<QAction *>(sender());
     int type = 0;
     if (act) {
         type = act->data().toInt();
     }
     QPointer<EncodingProfilesDialog> dia = new EncodingProfilesDialog(type);
     dia->exec();
     delete dia;
     loadEncodingProfiles();
 }
 
 void KdenliveSettingsDialog::loadExternalProxyProfiles()
 {
     // load proxy profiles
     KConfig conf(QStringLiteral("externalproxies.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     KConfigGroup group(&conf, "proxy");
     QMap<QString, QString> values = group.entryMap();
     QMapIterator<QString, QString> k(values);
     QString currentItem = KdenliveSettings::externalProxyProfile();
     m_configProxy.kcfg_external_proxy_profile->blockSignals(true);
     m_configProxy.kcfg_external_proxy_profile->clear();
     while (k.hasNext()) {
         k.next();
         if (!k.key().isEmpty()) {
             if (k.value().contains(QLatin1Char(';'))) {
                 m_configProxy.kcfg_external_proxy_profile->addItem(k.key(), k.value());
             }
         }
     }
     if (!currentItem.isEmpty()) {
         m_configProxy.kcfg_external_proxy_profile->setCurrentIndex(m_configProxy.kcfg_external_proxy_profile->findText(currentItem));
     }
     m_configProxy.kcfg_external_proxy_profile->blockSignals(false);
 }
 
 void KdenliveSettingsDialog::loadEncodingProfiles()
 {
     KConfig conf(QStringLiteral("encodingprofiles.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
 
     // Load v4l profiles
     m_configCapture.kcfg_v4l_profile->blockSignals(true);
     QString currentItem = m_configCapture.kcfg_v4l_profile->currentText();
     m_configCapture.kcfg_v4l_profile->clear();
     KConfigGroup group(&conf, "video4linux");
     QMap<QString, QString> values = group.entryMap();
     QMapIterator<QString, QString> i(values);
     while (i.hasNext()) {
         i.next();
         if (!i.key().isEmpty()) {
             m_configCapture.kcfg_v4l_profile->addItem(i.key(), i.value());
         }
     }
     m_configCapture.kcfg_v4l_profile->blockSignals(false);
     if (!currentItem.isEmpty()) {
         m_configCapture.kcfg_v4l_profile->setCurrentIndex(m_configCapture.kcfg_v4l_profile->findText(currentItem));
     }
 
     // Load Screen Grab profiles
     m_configCapture.kcfg_grab_profile->blockSignals(true);
     currentItem = m_configCapture.kcfg_grab_profile->currentText();
     m_configCapture.kcfg_grab_profile->clear();
     KConfigGroup group2(&conf, "screengrab");
     values = group2.entryMap();
     QMapIterator<QString, QString> j(values);
     while (j.hasNext()) {
         j.next();
         if (!j.key().isEmpty()) {
             m_configCapture.kcfg_grab_profile->addItem(j.key(), j.value());
         }
     }
     m_configCapture.kcfg_grab_profile->blockSignals(false);
     if (!currentItem.isEmpty()) {
         m_configCapture.kcfg_grab_profile->setCurrentIndex(m_configCapture.kcfg_grab_profile->findText(currentItem));
     }
 
     // Load Decklink profiles
     m_configCapture.kcfg_decklink_profile->blockSignals(true);
     currentItem = m_configCapture.kcfg_decklink_profile->currentText();
     m_configCapture.kcfg_decklink_profile->clear();
     KConfigGroup group3(&conf, "decklink");
     values = group3.entryMap();
     QMapIterator<QString, QString> k(values);
     while (k.hasNext()) {
         k.next();
         if (!k.key().isEmpty()) {
             m_configCapture.kcfg_decklink_profile->addItem(k.key(), k.value());
         }
     }
     m_configCapture.kcfg_decklink_profile->blockSignals(false);
     if (!currentItem.isEmpty()) {
         m_configCapture.kcfg_decklink_profile->setCurrentIndex(m_configCapture.kcfg_decklink_profile->findText(currentItem));
     }
 
     // Load Timeline Preview profiles
     m_configProject.kcfg_preview_profile->blockSignals(true);
     currentItem = m_configProject.kcfg_preview_profile->currentText();
     m_configProject.kcfg_preview_profile->clear();
     KConfigGroup group5(&conf, "timelinepreview");
     values = group5.entryMap();
     m_configProject.kcfg_preview_profile->addItem(i18n("Automatic"));
     QMapIterator<QString, QString> l(values);
     while (l.hasNext()) {
         l.next();
         if (!l.key().isEmpty()) {
             m_configProject.kcfg_preview_profile->addItem(l.key(), l.value());
         }
     }
     if (!currentItem.isEmpty()) {
         m_configProject.kcfg_preview_profile->setCurrentIndex(m_configProject.kcfg_preview_profile->findText(currentItem));
     }
     m_configProject.kcfg_preview_profile->blockSignals(false);
     QString profilestr = m_configProject.kcfg_preview_profile->itemData(m_configProject.kcfg_preview_profile->currentIndex()).toString();
     if (profilestr.isEmpty()) {
         m_configProject.previewparams->clear();
     } else {
         m_configProject.previewparams->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
     }
 
     // Load Proxy profiles
     m_configProxy.kcfg_proxy_profile->blockSignals(true);
     currentItem = m_configProxy.kcfg_proxy_profile->currentText();
     m_configProxy.kcfg_proxy_profile->clear();
     KConfigGroup group4(&conf, "proxy");
     values = group4.entryMap();
     m_configProxy.kcfg_proxy_profile->addItem(i18n("Automatic"));
     QMapIterator<QString, QString> m(values);
     while (m.hasNext()) {
         m.next();
         if (!m.key().isEmpty()) {
             m_configProxy.kcfg_proxy_profile->addItem(m.key(), m.value());
         }
     }
     if (!currentItem.isEmpty()) {
         m_configProxy.kcfg_proxy_profile->setCurrentIndex(m_configProxy.kcfg_proxy_profile->findText(currentItem));
     }
     m_configProxy.kcfg_proxy_profile->blockSignals(false);
     profilestr = m_configProxy.kcfg_proxy_profile->itemData(m_configProxy.kcfg_proxy_profile->currentIndex()).toString();
     if (profilestr.isEmpty()) {
         m_configProxy.proxyparams->clear();
     } else {
         m_configProxy.proxyparams->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
     }
 }
 
 void KdenliveSettingsDialog::slotUpdateDecklinkProfile(int ix)
 {
     if (ix == -1) {
         ix = KdenliveSettings::decklink_profile();
     } else {
         ix = m_configCapture.kcfg_decklink_profile->currentIndex();
     }
     QString profilestr = m_configCapture.kcfg_decklink_profile->itemData(ix).toString();
     if (profilestr.isEmpty()) {
         return;
     }
     m_configCapture.decklink_parameters->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
     //
 }
 
 void KdenliveSettingsDialog::slotUpdateV4lProfile(int ix)
 {
     if (ix == -1) {
         ix = KdenliveSettings::v4l_profile();
     } else {
         ix = m_configCapture.kcfg_v4l_profile->currentIndex();
     }
     QString profilestr = m_configCapture.kcfg_v4l_profile->itemData(ix).toString();
     if (profilestr.isEmpty()) {
         return;
     }
     m_configCapture.v4l_parameters->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
     //
 }
 
 void KdenliveSettingsDialog::slotUpdateGrabProfile(int ix)
 {
     if (ix == -1) {
         ix = KdenliveSettings::grab_profile();
     } else {
         ix = m_configCapture.kcfg_grab_profile->currentIndex();
     }
     QString profilestr = m_configCapture.kcfg_grab_profile->itemData(ix).toString();
     if (profilestr.isEmpty()) {
         return;
     }
     m_configCapture.grab_parameters->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
     //
 }
 
 void KdenliveSettingsDialog::slotUpdateProxyProfile(int ix)
 {
     if (ix == -1) {
         ix = KdenliveSettings::proxy_profile();
     } else {
         ix = m_configProxy.kcfg_proxy_profile->currentIndex();
     }
     QString profilestr = m_configProxy.kcfg_proxy_profile->itemData(ix).toString();
     if (profilestr.isEmpty()) {
         return;
     }
     m_configProxy.proxyparams->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
 }
 
 void KdenliveSettingsDialog::slotUpdatePreviewProfile(int ix)
 {
     if (ix == -1) {
         ix = KdenliveSettings::preview_profile();
     } else {
         ix = m_configProject.kcfg_preview_profile->currentIndex();
     }
     QString profilestr = m_configProject.kcfg_preview_profile->itemData(ix).toString();
     if (profilestr.isEmpty()) {
         return;
     }
     m_configProject.previewparams->setPlainText(profilestr.section(QLatin1Char(';'), 0, 0));
 }
 
 void KdenliveSettingsDialog::slotEditVideo4LinuxProfile()
 {
     QString vl4ProfilePath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/profiles/video4linux");
     QPointer<ProfilesDialog> w = new ProfilesDialog(vl4ProfilePath, true);
     if (w->exec() == QDialog::Accepted) {
         // save and update profile
         loadCurrentV4lProfileInfo();
     }
     delete w;
 }
 
 void KdenliveSettingsDialog::slotReloadBlackMagic()
 {
     getBlackMagicDeviceList(m_configCapture.kcfg_decklink_capturedevice, true);
     if (!getBlackMagicOutputDeviceList(m_configSdl.kcfg_blackmagic_output_device, true)) {
         // No blackmagic card found
         m_configSdl.kcfg_external_display->setEnabled(false);
     }
     m_configSdl.kcfg_external_display->setEnabled(KdenliveSettings::decklink_device_found());
 }
 
 void KdenliveSettingsDialog::checkProfile()
 {
     m_pw->loadProfile(KdenliveSettings::default_profile().isEmpty() ? pCore->getCurrentProfile()->path() : KdenliveSettings::default_profile());
 }
 
 void KdenliveSettingsDialog::slotReloadShuttleDevices()
 {
 #ifdef USE_JOGSHUTTLE
     QString devDirStr = QStringLiteral("/dev/input/by-id");
     QDir devDir(devDirStr);
     if (!devDir.exists()) {
         devDirStr = QStringLiteral("/dev/input");
     }
 
     QStringList devNamesList;
     QStringList devPathList;
     m_configShuttle.shuttledevicelist->clear();
 
     DeviceMap devMap = JogShuttle::enumerateDevices(devDirStr);
     DeviceMapIter iter = devMap.begin();
     while (iter != devMap.end()) {
         m_configShuttle.shuttledevicelist->addItem(iter.key(), iter.value());
         devNamesList << iter.key();
         devPathList << iter.value();
         ++iter;
     }
     KdenliveSettings::setShuttledevicenames(devNamesList);
     KdenliveSettings::setShuttledevicepaths(devPathList);
     QTimer::singleShot(200, this, SLOT(slotUpdateShuttleDevice()));
 #endif // USE_JOGSHUTTLE
 }
 
 void KdenliveSettingsDialog::slotUpdateAudioCaptureChannels(int index)
 {
     KdenliveSettings::setAudiocapturechannels(m_configCapture.audiocapturechannels->itemData(index).toInt());
 }
 
 void KdenliveSettingsDialog::slotUpdateAudioCaptureSampleRate(int index)
 {
     KdenliveSettings::setAudiocapturesamplerate(m_configCapture.audiocapturesamplerate->itemData(index).toInt());
 }
diff --git a/src/dialogs/renderwidget.cpp b/src/dialogs/renderwidget.cpp
index 460668de6..4f88aab87 100644
--- a/src/dialogs/renderwidget.cpp
+++ b/src/dialogs/renderwidget.cpp
@@ -1,3098 +1,3094 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "renderwidget.h"
 #include "bin/projectitemmodel.h"
 #include "bin/bin.h"
 #include "core.h"
 #include "dialogs/profilesdialog.h"
 #include "doc/kdenlivedoc.h"
 #include "kdenlivesettings.h"
 #include "monitor/monitor.h"
 #include "profiles/profilemodel.hpp"
 #include "profiles/profilerepository.hpp"
 #include "project/projectmanager.h"
 #include "timecode.h"
 #include "ui_saveprofile_ui.h"
 #include "xml/xml.hpp"
 
 #include "klocalizedstring.h"
 #include <KColorScheme>
 #include <KIO/DesktopExecParser>
 #include <KMessageBox>
 #include <KNotification>
 #include <KRun>
 #include <kio_version.h>
 #include <knotifications_version.h>
 #include <kns3/downloaddialog.h>
 
 #include "kdenlive_debug.h"
 #include <QDBusConnectionInterface>
 #include <QDir>
 #include <QDomDocument>
 #include <QFileIconProvider>
 #include <QHeaderView>
 #include <QInputDialog>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QKeyEvent>
 #include <QMimeDatabase>
 #include <QProcess>
 #include <QStandardPaths>
 #include <QTemporaryFile>
 #include <QThread>
 #include <QTreeWidgetItem>
 #include <qglobal.h>
 #include <qstring.h>
 #include <QMenu>
 
 #ifdef KF5_USE_PURPOSE
 #include <Purpose/AlternativesModel>
 #include <PurposeWidgets/Menu>
 #endif
 
 #include <locale>
 #ifdef Q_OS_MAC
 #include <xlocale.h>
 #endif
 
 // Render profiles roles
 enum {
     GroupRole = Qt::UserRole,
     ExtensionRole,
     StandardRole,
     RenderRole,
     ParamsRole,
     EditableRole,
     ExtraRole,
     BitratesRole,
     DefaultBitrateRole,
     AudioBitratesRole,
     DefaultAudioBitrateRole,
     SpeedsRole,
     FieldRole,
     ErrorRole
 };
 
 // Render job roles
 const int ParametersRole = Qt::UserRole + 1;
 const int TimeRole = Qt::UserRole + 2;
 const int ProgressRole = Qt::UserRole + 3;
 const int ExtraInfoRole = Qt::UserRole + 5;
 
 // Running job status
 enum JOBSTATUS { WAITINGJOB = 0, STARTINGJOB, RUNNINGJOB, FINISHEDJOB, FAILEDJOB, ABORTEDJOB };
 
 static QStringList acodecsList;
 static QStringList vcodecsList;
 static QStringList supportedFormats;
 
 RenderJobItem::RenderJobItem(QTreeWidget *parent, const QStringList &strings, int type)
     : QTreeWidgetItem(parent, strings, type)
     , m_status(-1)
 {
     setSizeHint(1, QSize(parent->columnWidth(1), parent->fontMetrics().height() * 3));
     setStatus(WAITINGJOB);
 }
 
 void RenderJobItem::setStatus(int status)
 {
     if (m_status == status) {
         return;
     }
     m_status = status;
     switch (status) {
     case WAITINGJOB:
         setIcon(0, QIcon::fromTheme(QStringLiteral("media-playback-pause")));
         setData(1, Qt::UserRole, i18n("Waiting..."));
         break;
     case FINISHEDJOB:
         setData(1, Qt::UserRole, i18n("Rendering finished"));
         setIcon(0, QIcon::fromTheme(QStringLiteral("dialog-ok")));
         setData(1, ProgressRole, 100);
         break;
     case FAILEDJOB:
         setData(1, Qt::UserRole, i18n("Rendering crashed"));
         setIcon(0, QIcon::fromTheme(QStringLiteral("dialog-close")));
         setData(1, ProgressRole, 100);
         break;
     case ABORTEDJOB:
         setData(1, Qt::UserRole, i18n("Rendering aborted"));
         setIcon(0, QIcon::fromTheme(QStringLiteral("dialog-cancel")));
         setData(1, ProgressRole, 100);
         break;
     default:
         break;
     }
 }
 
 int RenderJobItem::status() const
 {
     return m_status;
 }
 
 void RenderJobItem::setMetadata(const QString &data)
 {
     m_data = data;
 }
 
 const QString RenderJobItem::metadata() const
 {
     return m_data;
 }
 
 RenderWidget::RenderWidget(bool enableProxy, QWidget *parent)
     : QDialog(parent)
     , m_blockProcessing(false)
 {
     m_view.setupUi(this);
     int size = style()->pixelMetric(QStyle::PM_SmallIconSize);
     QSize iconSize(size, size);
 
     setWindowTitle(i18n("Rendering"));
     m_view.buttonDelete->setIconSize(iconSize);
     m_view.buttonEdit->setIconSize(iconSize);
     m_view.buttonSave->setIconSize(iconSize);
     m_view.buttonFavorite->setIconSize(iconSize);
     m_view.buttonDownload->setIconSize(iconSize);
 
     m_view.buttonDelete->setIcon(QIcon::fromTheme(QStringLiteral("trash-empty")));
     m_view.buttonDelete->setToolTip(i18n("Delete profile"));
     m_view.buttonDelete->setEnabled(false);
 
     m_view.buttonEdit->setIcon(QIcon::fromTheme(QStringLiteral("document-edit")));
     m_view.buttonEdit->setToolTip(i18n("Edit profile"));
     m_view.buttonEdit->setEnabled(false);
 
     m_view.buttonSave->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
     m_view.buttonSave->setToolTip(i18n("Create new profile"));
 
     m_view.hide_log->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
 
     m_view.buttonFavorite->setIcon(QIcon::fromTheme(QStringLiteral("favorite")));
     m_view.buttonFavorite->setToolTip(i18n("Copy profile to favorites"));
 
     m_view.buttonDownload->setIcon(QIcon::fromTheme(QStringLiteral("edit-download")));
     m_view.buttonDownload->setToolTip(i18n("Download New Render Profiles..."));
 
     m_view.out_file->button()->setToolTip(i18n("Select output destination"));
     m_view.advanced_params->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
 
     m_view.optionsGroup->setVisible(m_view.options->isChecked());
     connect(m_view.options, &QAbstractButton::toggled, m_view.optionsGroup, &QWidget::setVisible);
     m_view.videoLabel->setVisible(m_view.options->isChecked());
     connect(m_view.options, &QAbstractButton::toggled, m_view.videoLabel, &QWidget::setVisible);
     m_view.video->setVisible(m_view.options->isChecked());
     connect(m_view.options, &QAbstractButton::toggled, m_view.video, &QWidget::setVisible);
     m_view.audioLabel->setVisible(m_view.options->isChecked());
     connect(m_view.options, &QAbstractButton::toggled, m_view.audioLabel, &QWidget::setVisible);
     m_view.audio->setVisible(m_view.options->isChecked());
     connect(m_view.options, &QAbstractButton::toggled, m_view.audio, &QWidget::setVisible);
     connect(m_view.quality, &QAbstractSlider::valueChanged, this, &RenderWidget::adjustAVQualities);
     connect(m_view.video, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &RenderWidget::adjustQuality);
     connect(m_view.speed, &QAbstractSlider::valueChanged, this, &RenderWidget::adjustSpeed);
 
     m_view.buttonRender->setEnabled(false);
     m_view.buttonGenerateScript->setEnabled(false);
     setRescaleEnabled(false);
     m_view.guides_box->setVisible(false);
     m_view.open_dvd->setVisible(false);
     m_view.create_chapter->setVisible(false);
     m_view.open_browser->setVisible(false);
     m_view.error_box->setVisible(false);
     m_view.tc_type->setEnabled(false);
     m_view.checkTwoPass->setEnabled(false);
     m_view.proxy_render->setHidden(!enableProxy);
     connect(m_view.proxy_render, &QCheckBox::toggled, this, &RenderWidget::slotProxyWarn);
     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
     QColor bg = scheme.background(KColorScheme::NegativeBackground).color();
     m_view.errorBox->setStyleSheet(
         QStringLiteral("QGroupBox { background-color: rgb(%1, %2, %3); border-radius: 5px;}; ").arg(bg.red()).arg(bg.green()).arg(bg.blue()));
     int height = QFontInfo(font()).pixelSize();
     m_view.errorIcon->setPixmap(QIcon::fromTheme(QStringLiteral("dialog-warning")).pixmap(height, height));
     m_view.errorBox->setHidden(true);
 
     m_infoMessage = new KMessageWidget;
     m_view.info->addWidget(m_infoMessage);
     m_infoMessage->setCloseButtonVisible(false);
     m_infoMessage->hide();
 
     m_jobInfoMessage = new KMessageWidget;
     m_view.jobInfo->addWidget(m_jobInfoMessage);
     m_jobInfoMessage->setCloseButtonVisible(false);
     m_jobInfoMessage->hide();
 
     m_view.encoder_threads->setMinimum(0);
     m_view.encoder_threads->setMaximum(QThread::idealThreadCount());
     m_view.encoder_threads->setToolTip(i18n("Encoding threads (0 is automatic)"));
     m_view.encoder_threads->setValue(KdenliveSettings::encodethreads());
     connect(m_view.encoder_threads, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &RenderWidget::slotUpdateEncodeThreads);
 
     m_view.rescale_keep->setChecked(KdenliveSettings::rescalekeepratio());
     connect(m_view.rescale_width, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &RenderWidget::slotUpdateRescaleWidth);
     connect(m_view.rescale_height, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &RenderWidget::slotUpdateRescaleHeight);
     m_view.rescale_keep->setIcon(QIcon::fromTheme(QStringLiteral("edit-link")));
     m_view.rescale_keep->setToolTip(i18n("Preserve aspect ratio"));
     connect(m_view.rescale_keep, &QAbstractButton::clicked, this, &RenderWidget::slotSwitchAspectRatio);
 
     connect(m_view.buttonRender, SIGNAL(clicked()), this, SLOT(slotPrepareExport()));
     connect(m_view.buttonGenerateScript, &QAbstractButton::clicked, this, &RenderWidget::slotGenerateScript);
 
     m_view.abort_job->setEnabled(false);
     m_view.start_script->setEnabled(false);
     m_view.delete_script->setEnabled(false);
 
     connect(m_view.export_audio, &QCheckBox::stateChanged, this, &RenderWidget::slotUpdateAudioLabel);
     m_view.export_audio->setCheckState(Qt::PartiallyChecked);
 
     checkCodecs();
     parseProfiles();
     parseScriptFiles();
     m_view.running_jobs->setUniformRowHeights(false);
     m_view.running_jobs->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_view.running_jobs, &QTreeWidget::customContextMenuRequested, this, &RenderWidget::prepareMenu);
     m_view.scripts_list->setUniformRowHeights(false);
     connect(m_view.start_script, &QAbstractButton::clicked, this, &RenderWidget::slotStartScript);
     connect(m_view.delete_script, &QAbstractButton::clicked, this, &RenderWidget::slotDeleteScript);
     connect(m_view.scripts_list, &QTreeWidget::itemSelectionChanged, this, &RenderWidget::slotCheckScript);
     connect(m_view.running_jobs, &QTreeWidget::itemSelectionChanged, this, &RenderWidget::slotCheckJob);
     connect(m_view.running_jobs, &QTreeWidget::itemDoubleClicked, this, &RenderWidget::slotPlayRendering);
 
     connect(m_view.buttonSave, &QAbstractButton::clicked, this, &RenderWidget::slotSaveProfile);
     connect(m_view.buttonEdit, &QAbstractButton::clicked, this, &RenderWidget::slotEditProfile);
     connect(m_view.buttonDelete, &QAbstractButton::clicked, this, &RenderWidget::slotDeleteProfile);
     connect(m_view.buttonFavorite, &QAbstractButton::clicked, this, &RenderWidget::slotCopyToFavorites);
     connect(m_view.buttonDownload, &QAbstractButton::clicked, this, &RenderWidget::slotDownloadNewRenderProfiles);
 
     connect(m_view.abort_job, &QAbstractButton::clicked, this, &RenderWidget::slotAbortCurrentJob);
     connect(m_view.start_job, &QAbstractButton::clicked, this, &RenderWidget::slotStartCurrentJob);
     connect(m_view.clean_up, &QAbstractButton::clicked, this, &RenderWidget::slotCLeanUpJobs);
     connect(m_view.hide_log, &QAbstractButton::clicked, this, &RenderWidget::slotHideLog);
 
     connect(m_view.buttonClose, &QAbstractButton::clicked, this, &QWidget::hide);
     connect(m_view.buttonClose2, &QAbstractButton::clicked, this, &QWidget::hide);
     connect(m_view.buttonClose3, &QAbstractButton::clicked, this, &QWidget::hide);
     connect(m_view.rescale, &QAbstractButton::toggled, this, &RenderWidget::setRescaleEnabled);
     connect(m_view.out_file, &KUrlRequester::textChanged, this, static_cast<void (RenderWidget::*)()>(&RenderWidget::slotUpdateButtons));
     connect(m_view.out_file, &KUrlRequester::urlSelected, this, static_cast<void (RenderWidget::*)(const QUrl &)>(&RenderWidget::slotUpdateButtons));
 
     connect(m_view.formats, &QTreeWidget::currentItemChanged, this, &RenderWidget::refreshParams);
     connect(m_view.formats, &QTreeWidget::itemDoubleClicked, this, &RenderWidget::slotEditItem);
 
     connect(m_view.render_guide, &QAbstractButton::clicked, this, &RenderWidget::slotUpdateGuideBox);
     connect(m_view.render_zone, &QAbstractButton::clicked, this, &RenderWidget::slotUpdateGuideBox);
     connect(m_view.render_full, &QAbstractButton::clicked, this, &RenderWidget::slotUpdateGuideBox);
 
     connect(m_view.guide_end, static_cast<void (KComboBox::*)(int)>(&KComboBox::activated), this, &RenderWidget::slotCheckStartGuidePosition);
     connect(m_view.guide_start, static_cast<void (KComboBox::*)(int)>(&KComboBox::activated), this, &RenderWidget::slotCheckEndGuidePosition);
 
     connect(m_view.tc_overlay, &QAbstractButton::toggled, m_view.tc_type, &QWidget::setEnabled);
 
     // m_view.splitter->setStretchFactor(1, 5);
     // m_view.splitter->setStretchFactor(0, 2);
 
     m_view.out_file->setAcceptMode(QFileDialog::AcceptSave);
     m_view.out_file->setMode(KFile::File);
     m_view.out_file->setFocusPolicy(Qt::ClickFocus);
 
     m_jobsDelegate = new RenderViewDelegate(this);
     m_view.running_jobs->setHeaderLabels(QStringList() << QString() << i18n("File"));
     m_view.running_jobs->setItemDelegate(m_jobsDelegate);
 
     QHeaderView *header = m_view.running_jobs->header();
     header->setSectionResizeMode(0, QHeaderView::Fixed);
     header->resizeSection(0, size + 4);
     header->setSectionResizeMode(1, QHeaderView::Interactive);
 
     m_view.scripts_list->setHeaderLabels(QStringList() << QString() << i18n("Stored Playlists"));
     m_scriptsDelegate = new RenderViewDelegate(this);
     m_view.scripts_list->setItemDelegate(m_scriptsDelegate);
     header = m_view.scripts_list->header();
     header->setSectionResizeMode(0, QHeaderView::Fixed);
     header->resizeSection(0, size + 4);
 
 // Find path for Kdenlive renderer
 #ifdef Q_OS_WIN
     m_renderer = QCoreApplication::applicationDirPath() + QStringLiteral("/kdenlive_render.exe");
 #else
     m_renderer = QCoreApplication::applicationDirPath() + QStringLiteral("/kdenlive_render");
 #endif
     if (!QFile::exists(m_renderer)) {
         m_renderer = QStandardPaths::findExecutable(QStringLiteral("kdenlive_render"));
         if (m_renderer.isEmpty()) {
             m_renderer = QStringLiteral("kdenlive_render");
         }
     }
 
     QDBusConnectionInterface *interface = QDBusConnection::sessionBus().interface();
     if ((interface == nullptr) ||
         (!interface->isServiceRegistered(QStringLiteral("org.kde.ksmserver")) && !interface->isServiceRegistered(QStringLiteral("org.gnome.SessionManager")))) {
         m_view.shutdown->setEnabled(false);
     }
 
 #ifdef KF5_USE_PURPOSE
     m_shareMenu = new Purpose::Menu();
     m_view.shareButton->setMenu(m_shareMenu);
     m_view.shareButton->setIcon(QIcon::fromTheme(QStringLiteral("document-share")));
     connect(m_shareMenu, &Purpose::Menu::finished, this, &RenderWidget::slotShareActionFinished);
 #else
     m_view.shareButton->setEnabled(false);
 #endif
     m_view.parallel_process->setChecked(KdenliveSettings::parallelrender());
     connect(m_view.parallel_process, &QCheckBox::stateChanged, [](int state) { KdenliveSettings::setParallelrender(state == Qt::Checked); });
     if (KdenliveSettings::gpu_accel()) {
         // Disable parallel rendering for movit
         m_view.parallel_process->setEnabled(false);
     }
     m_view.field_order->setEnabled(false);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_view.scanning_list, QOverload<int>::of(&QComboBox::currentIndexChanged), [this](int index) { m_view.field_order->setEnabled(index == 2); });
-#else
-    connect(m_view.scanning_list, QOverload<int, const QString &>::of(&QComboBox::currentIndexChanged), [this](int index) { m_view.field_order->setEnabled(index == 2); });
-#endif
     refreshView();
     focusFirstVisibleItem();
     adjustSize();
 }
 
 void RenderWidget::slotShareActionFinished(const QJsonObject &output, int error, const QString &message)
 {
 #ifdef KF5_USE_PURPOSE
     m_jobInfoMessage->hide();
     if (error) {
         KMessageBox::error(this, i18n("There was a problem sharing the document: %1", message), i18n("Share"));
     } else {
         const QString url = output["url"].toString();
         if (url.isEmpty()) {
             m_jobInfoMessage->setMessageType(KMessageWidget::Positive);
             m_jobInfoMessage->setText(i18n("Document shared successfully"));
             m_jobInfoMessage->show();
         } else {
             KMessageBox::information(this, i18n("You can find the shared document at: <a href=\"%1\">%1</a>", url), i18n("Share"), QString(),
                                      KMessageBox::Notify | KMessageBox::AllowLink);
         }
     }
 #else
     Q_UNUSED(output);
     Q_UNUSED(error);
     Q_UNUSED(message);
 #endif
 }
 
 QSize RenderWidget::sizeHint() const
 {
     // Make sure the widget has minimum size on opening
     return {200, 200};
 }
 
 RenderWidget::~RenderWidget()
 {
     m_view.running_jobs->blockSignals(true);
     m_view.scripts_list->blockSignals(true);
     m_view.running_jobs->clear();
     m_view.scripts_list->clear();
     delete m_jobsDelegate;
     delete m_scriptsDelegate;
     delete m_infoMessage;
     delete m_jobInfoMessage;
 }
 
 void RenderWidget::slotEditItem(QTreeWidgetItem *item)
 {
     if (item->parent() == nullptr) {
         // This is a top level item - group - don't edit
         return;
     }
     const QString edit = item->data(0, EditableRole).toString();
     if (edit.isEmpty() || !edit.endsWith(QLatin1String("customprofiles.xml"))) {
         slotSaveProfile();
     } else {
         slotEditProfile();
     }
 }
 
 void RenderWidget::showInfoPanel()
 {
     if (m_view.advanced_params->isVisible()) {
         m_view.advanced_params->setVisible(false);
         KdenliveSettings::setShowrenderparams(false);
     } else {
         m_view.advanced_params->setVisible(true);
         KdenliveSettings::setShowrenderparams(true);
     }
 }
 
 void RenderWidget::updateDocumentPath()
 {
     if (m_view.out_file->url().isEmpty()) {
         return;
     }
     const QString fileName = m_view.out_file->url().fileName();
     m_view.out_file->setUrl(QUrl::fromLocalFile(QDir(pCore->currentDoc()->projectDataFolder()).absoluteFilePath(fileName)));
     parseScriptFiles();
 }
 
 void RenderWidget::slotUpdateGuideBox()
 {
     m_view.guides_box->setVisible(m_view.render_guide->isChecked());
 }
 
 void RenderWidget::slotCheckStartGuidePosition()
 {
     if (m_view.guide_start->currentIndex() > m_view.guide_end->currentIndex()) {
         m_view.guide_start->setCurrentIndex(m_view.guide_end->currentIndex());
     }
 }
 
 void RenderWidget::slotCheckEndGuidePosition()
 {
     if (m_view.guide_end->currentIndex() < m_view.guide_start->currentIndex()) {
         m_view.guide_end->setCurrentIndex(m_view.guide_start->currentIndex());
     }
 }
 
 void RenderWidget::setGuides(std::weak_ptr<MarkerListModel> guidesModel)
 {
     m_guidesModel = std::move(guidesModel);
     reloadGuides();
     if (auto ptr = m_guidesModel.lock()) {
         connect(ptr.get(), &MarkerListModel::modelChanged, this, &RenderWidget::reloadGuides);
     }
 }
 
 void RenderWidget::reloadGuides()
 {
     double projectDuration = GenTime(pCore->projectDuration() - TimelineModel::seekDuration - 2, pCore->getCurrentFps()).ms() / 1000;
     QVariant startData = m_view.guide_start->currentData();
     QVariant endData = m_view.guide_end->currentData();
     m_view.guide_start->clear();
     m_view.guide_end->clear();
     if (auto ptr = m_guidesModel.lock()) {
         QList<CommentedTime> markers = ptr->getAllMarkers();
         double fps = pCore->getCurrentProfile()->fps();
         m_view.render_guide->setEnabled(!markers.isEmpty());
         if (!markers.isEmpty()) {
             m_view.guide_start->addItem(i18n("Beginning"), "0");
             m_view.create_chapter->setEnabled(true);
             for (auto marker : markers) {
                 GenTime pos = marker.time();
                 const QString guidePos = Timecode::getStringTimecode(pos.frames(fps), fps);
                 m_view.guide_start->addItem(marker.comment() + QLatin1Char('/') + guidePos, pos.seconds());
                 m_view.guide_end->addItem(marker.comment() + QLatin1Char('/') + guidePos, pos.seconds());
             }
             m_view.guide_end->addItem(i18n("End"), QString::number(projectDuration));
             if (!startData.isNull()) {
                 int ix = qMax(0, m_view.guide_start->findData(startData));
                 m_view.guide_start->setCurrentIndex(ix);
             }
             if (!endData.isNull()) {
                 int ix = qMax(m_view.guide_start->currentIndex() + 1, m_view.guide_end->findData(endData));
                 m_view.guide_end->setCurrentIndex(ix);
             }
         }
     } else {
         m_view.render_guide->setEnabled(false);
         m_view.create_chapter->setEnabled(false);
     }
 }
 
 /**
  * Will be called when the user selects an output file via the file dialog.
  * File extension will be added automatically.
  */
 void RenderWidget::slotUpdateButtons(const QUrl &url)
 {
     if (m_view.out_file->url().isEmpty()) {
         m_view.buttonGenerateScript->setEnabled(false);
         m_view.buttonRender->setEnabled(false);
     } else {
         updateButtons(); // This also checks whether the selected format is available
     }
     if (url.isValid()) {
         QTreeWidgetItem *item = m_view.formats->currentItem();
         if ((item == nullptr) || (item->parent() == nullptr)) { // categories have no parent
             m_view.buttonRender->setEnabled(false);
             m_view.buttonGenerateScript->setEnabled(false);
             return;
         }
         const QString extension = item->data(0, ExtensionRole).toString();
         m_view.out_file->setUrl(filenameWithExtension(url, extension));
     }
 }
 
 /**
  * Will be called when the user changes the output file path in the text line.
  * File extension must NOT be added, would make editing impossible!
  */
 void RenderWidget::slotUpdateButtons()
 {
     if (m_view.out_file->url().isEmpty()) {
         m_view.buttonRender->setEnabled(false);
         m_view.buttonGenerateScript->setEnabled(false);
     } else {
         updateButtons(); // This also checks whether the selected format is available
     }
 }
 
 void RenderWidget::slotSaveProfile()
 {
     Ui::SaveProfile_UI ui;
     QPointer<QDialog> d = new QDialog(this);
     ui.setupUi(d);
 
     QString customGroup;
     QStringList arguments = m_view.advanced_params->toPlainText().split(' ', QString::SkipEmptyParts);
     if (!arguments.isEmpty()) {
         ui.parameters->setText(arguments.join(QLatin1Char(' ')));
     }
     ui.profile_name->setFocus();
     QTreeWidgetItem *item = m_view.formats->currentItem();
     if ((item != nullptr) && (item->parent() != nullptr)) { // not a category
         // Duplicate current item settings
         customGroup = item->parent()->text(0);
         ui.extension->setText(item->data(0, ExtensionRole).toString());
         if (ui.parameters->toPlainText().contains(QStringLiteral("%bitrate")) || ui.parameters->toPlainText().contains(QStringLiteral("%quality"))) {
             if (ui.parameters->toPlainText().contains(QStringLiteral("%quality"))) {
                 ui.vbitrates_label->setText(i18n("Qualities"));
                 ui.default_vbitrate_label->setText(i18n("Default quality"));
             } else {
                 ui.vbitrates_label->setText(i18n("Bitrates"));
                 ui.default_vbitrate_label->setText(i18n("Default bitrate"));
             }
             if (item->data(0, BitratesRole).canConvert(QVariant::StringList) && (item->data(0, BitratesRole).toStringList().count() != 0)) {
                 QStringList bitrates = item->data(0, BitratesRole).toStringList();
                 ui.vbitrates_list->setText(bitrates.join(QLatin1Char(',')));
                 if (item->data(0, DefaultBitrateRole).canConvert(QVariant::String)) {
                     ui.default_vbitrate->setValue(item->data(0, DefaultBitrateRole).toInt());
                 }
             }
         } else {
             ui.vbitrates->setHidden(true);
         }
         if (ui.parameters->toPlainText().contains(QStringLiteral("%audiobitrate")) || ui.parameters->toPlainText().contains(QStringLiteral("%audioquality"))) {
             if (ui.parameters->toPlainText().contains(QStringLiteral("%audioquality"))) {
                 ui.abitrates_label->setText(i18n("Qualities"));
                 ui.default_abitrate_label->setText(i18n("Default quality"));
             } else {
                 ui.abitrates_label->setText(i18n("Bitrates"));
                 ui.default_abitrate_label->setText(i18n("Default bitrate"));
             }
             if ((item != nullptr) && item->data(0, AudioBitratesRole).canConvert(QVariant::StringList) &&
                 (item->data(0, AudioBitratesRole).toStringList().count() != 0)) {
                 QStringList bitrates = item->data(0, AudioBitratesRole).toStringList();
                 ui.abitrates_list->setText(bitrates.join(QLatin1Char(',')));
                 if (item->data(0, DefaultAudioBitrateRole).canConvert(QVariant::String)) {
                     ui.default_abitrate->setValue(item->data(0, DefaultAudioBitrateRole).toInt());
                 }
             }
         } else {
             ui.abitrates->setHidden(true);
         }
 
         if (item->data(0, SpeedsRole).canConvert(QVariant::StringList) && (item->data(0, SpeedsRole).toStringList().count() != 0)) {
             QStringList speeds = item->data(0, SpeedsRole).toStringList();
             ui.speeds_list->setText(speeds.join('\n'));
         }
     }
 
     if (customGroup.isEmpty()) {
         customGroup = i18nc("Group Name", "Custom");
     }
     ui.group_name->setText(customGroup);
 
     if (d->exec() == QDialog::Accepted && !ui.profile_name->text().simplified().isEmpty()) {
         QString newProfileName = ui.profile_name->text().simplified();
         QString newGroupName = ui.group_name->text().simplified();
         if (newGroupName.isEmpty()) {
             newGroupName = i18nc("Group Name", "Custom");
         }
 
         QDomDocument doc;
         QDomElement profileElement = doc.createElement(QStringLiteral("profile"));
         profileElement.setAttribute(QStringLiteral("name"), newProfileName);
         profileElement.setAttribute(QStringLiteral("category"), newGroupName);
         profileElement.setAttribute(QStringLiteral("extension"), ui.extension->text().simplified());
         QString args = ui.parameters->toPlainText().simplified();
         profileElement.setAttribute(QStringLiteral("args"), args);
         if (args.contains(QStringLiteral("%bitrate"))) {
             // profile has a variable bitrate
             profileElement.setAttribute(QStringLiteral("defaultbitrate"), QString::number(ui.default_vbitrate->value()));
             profileElement.setAttribute(QStringLiteral("bitrates"), ui.vbitrates_list->text());
         } else if (args.contains(QStringLiteral("%quality"))) {
             profileElement.setAttribute(QStringLiteral("defaultquality"), QString::number(ui.default_vbitrate->value()));
             profileElement.setAttribute(QStringLiteral("qualities"), ui.vbitrates_list->text());
         }
 
         if (args.contains(QStringLiteral("%audiobitrate"))) {
             // profile has a variable bitrate
             profileElement.setAttribute(QStringLiteral("defaultaudiobitrate"), QString::number(ui.default_abitrate->value()));
             profileElement.setAttribute(QStringLiteral("audiobitrates"), ui.abitrates_list->text());
         } else if (args.contains(QStringLiteral("%audioquality"))) {
             // profile has a variable bitrate
             profileElement.setAttribute(QStringLiteral("defaultaudioquality"), QString::number(ui.default_abitrate->value()));
             profileElement.setAttribute(QStringLiteral("audioqualities"), ui.abitrates_list->text());
         }
         QString speeds_list_str = ui.speeds_list->toPlainText();
         if (!speeds_list_str.isEmpty()) {
             profileElement.setAttribute(QStringLiteral("speeds"), speeds_list_str.replace('\n', ';').simplified());
         }
 
         doc.appendChild(profileElement);
         saveProfile(doc.documentElement());
 
         parseProfiles();
     }
     delete d;
 }
 
 bool RenderWidget::saveProfile(QDomElement newprofile)
 {
     QDir dir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/export/"));
     if (!dir.exists()) {
         dir.mkpath(QStringLiteral("."));
     }
     QDomDocument doc;
     QFile file(dir.absoluteFilePath(QStringLiteral("customprofiles.xml")));
     doc.setContent(&file, false);
     file.close();
     QDomElement documentElement;
     QDomElement profiles = doc.documentElement();
     if (profiles.isNull() || profiles.tagName() != QLatin1String("profiles")) {
         doc.clear();
         profiles = doc.createElement(QStringLiteral("profiles"));
         profiles.setAttribute(QStringLiteral("version"), 1);
         doc.appendChild(profiles);
     }
     int version = profiles.attribute(QStringLiteral("version"), nullptr).toInt();
     if (version < 1) {
         doc.clear();
         profiles = doc.createElement(QStringLiteral("profiles"));
         profiles.setAttribute(QStringLiteral("version"), 1);
         doc.appendChild(profiles);
     }
 
     QDomNodeList profilelist = doc.elementsByTagName(QStringLiteral("profile"));
     QString newProfileName = newprofile.attribute(QStringLiteral("name"));
     // Check existing profiles
     QStringList existingProfileNames;
     int i = 0;
     while (!profilelist.item(i).isNull()) {
         documentElement = profilelist.item(i).toElement();
         QString profileName = documentElement.attribute(QStringLiteral("name"));
         existingProfileNames << profileName;
         i++;
     }
     // Check if a profile with that same name already exists
     bool ok;
     while (existingProfileNames.contains(newProfileName)) {
         QString updatedProfileName = QInputDialog::getText(this, i18n("Profile already exists"),
                                                            i18n("This profile name already exists. Change the name if you do not want to overwrite it."),
                                                            QLineEdit::Normal, newProfileName, &ok);
         if (!ok) {
             return false;
         }
         if (updatedProfileName == newProfileName) {
             // remove previous profile
             profiles.removeChild(profilelist.item(existingProfileNames.indexOf(newProfileName)));
             break;
         } else {
             newProfileName = updatedProfileName;
             newprofile.setAttribute(QStringLiteral("name"), newProfileName);
         }
     }
 
     profiles.appendChild(newprofile);
 
     // QCString save = doc.toString().utf8();
 
     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         KMessageBox::sorry(this, i18n("Unable to write to file %1", dir.absoluteFilePath("customprofiles.xml")));
         return false;
     }
     QTextStream out(&file);
     out << doc.toString();
     if (file.error() != QFile::NoError) {
         KMessageBox::error(this, i18n("Cannot write to file %1", dir.absoluteFilePath("customprofiles.xml")));
         file.close();
         return false;
     }
     file.close();
     return true;
 }
 
 void RenderWidget::slotCopyToFavorites()
 {
     QTreeWidgetItem *item = m_view.formats->currentItem();
     if ((item == nullptr) || (item->parent() == nullptr)) {
         return;
     }
 
     QString params = item->data(0, ParamsRole).toString();
     QString extension = item->data(0, ExtensionRole).toString();
     QString currentProfile = item->text(0);
     QDomDocument doc;
     QDomElement profileElement = doc.createElement(QStringLiteral("profile"));
     profileElement.setAttribute(QStringLiteral("name"), currentProfile);
     profileElement.setAttribute(QStringLiteral("category"), i18nc("Category Name", "Custom"));
     profileElement.setAttribute(QStringLiteral("destinationid"), QStringLiteral("favorites"));
     profileElement.setAttribute(QStringLiteral("extension"), extension);
     profileElement.setAttribute(QStringLiteral("args"), params);
     if (params.contains(QStringLiteral("%bitrate"))) {
         // profile has a variable bitrate
         profileElement.setAttribute(QStringLiteral("defaultbitrate"), item->data(0, DefaultBitrateRole).toString());
         profileElement.setAttribute(QStringLiteral("bitrates"), item->data(0, BitratesRole).toStringList().join(QLatin1Char(',')));
     } else if (params.contains(QStringLiteral("%quality"))) {
         profileElement.setAttribute(QStringLiteral("defaultquality"), item->data(0, DefaultBitrateRole).toString());
         profileElement.setAttribute(QStringLiteral("qualities"), item->data(0, BitratesRole).toStringList().join(QLatin1Char(',')));
     }
     if (params.contains(QStringLiteral("%audiobitrate"))) {
         // profile has a variable bitrate
         profileElement.setAttribute(QStringLiteral("defaultaudiobitrate"), item->data(0, DefaultAudioBitrateRole).toString());
         profileElement.setAttribute(QStringLiteral("audiobitrates"), item->data(0, AudioBitratesRole).toStringList().join(QLatin1Char(',')));
     } else if (params.contains(QStringLiteral("%audioquality"))) {
         // profile has a variable bitrate
         profileElement.setAttribute(QStringLiteral("defaultaudioquality"), item->data(0, DefaultAudioBitrateRole).toString());
         profileElement.setAttribute(QStringLiteral("audioqualities"), item->data(0, AudioBitratesRole).toStringList().join(QLatin1Char(',')));
     }
     if (item->data(0, SpeedsRole).canConvert(QVariant::StringList) && (item->data(0, SpeedsRole).toStringList().count() != 0)) {
         // profile has a variable speed
         profileElement.setAttribute(QStringLiteral("speeds"), item->data(0, SpeedsRole).toStringList().join(QLatin1Char(';')));
     }
     doc.appendChild(profileElement);
     if (saveProfile(doc.documentElement())) {
         parseProfiles(profileElement.attribute(QStringLiteral("name")));
     }
 }
 
 void RenderWidget::slotDownloadNewRenderProfiles()
 {
     if (getNewStuff(QStringLiteral(":data/kdenlive_renderprofiles.knsrc")) > 0) {
         reloadProfiles();
     }
 }
 
 int RenderWidget::getNewStuff(const QString &configFile)
 {
     KNS3::Entry::List entries;
     QPointer<KNS3::DownloadDialog> dialog = new KNS3::DownloadDialog(configFile);
     if (dialog->exec() != 0) {
         entries = dialog->changedEntries();
     }
     for (const KNS3::Entry &entry : entries) {
         if (entry.status() == KNS3::Entry::Installed) {
             qCDebug(KDENLIVE_LOG) << "// Installed files: " << entry.installedFiles();
         }
     }
     delete dialog;
     return entries.size();
 }
 
 void RenderWidget::slotEditProfile()
 {
     QTreeWidgetItem *item = m_view.formats->currentItem();
     if ((item == nullptr) || (item->parent() == nullptr)) {
         return;
     }
     QString params = item->data(0, ParamsRole).toString();
 
     Ui::SaveProfile_UI ui;
     QPointer<QDialog> d = new QDialog(this);
     ui.setupUi(d);
 
     QString customGroup = item->parent()->text(0);
     if (customGroup.isEmpty()) {
         customGroup = i18nc("Group Name", "Custom");
     }
     ui.group_name->setText(customGroup);
 
     ui.profile_name->setText(item->text(0));
     ui.extension->setText(item->data(0, ExtensionRole).toString());
     ui.parameters->setText(params);
     ui.profile_name->setFocus();
     if (params.contains(QStringLiteral("%bitrate")) || ui.parameters->toPlainText().contains(QStringLiteral("%quality"))) {
         if (params.contains(QStringLiteral("%quality"))) {
             ui.vbitrates_label->setText(i18n("Qualities"));
             ui.default_vbitrate_label->setText(i18n("Default quality"));
         } else {
             ui.vbitrates_label->setText(i18n("Bitrates"));
             ui.default_vbitrate_label->setText(i18n("Default bitrate"));
         }
         if (item->data(0, BitratesRole).canConvert(QVariant::StringList) && (item->data(0, BitratesRole).toStringList().count() != 0)) {
             QStringList bitrates = item->data(0, BitratesRole).toStringList();
             ui.vbitrates_list->setText(bitrates.join(QLatin1Char(',')));
             if (item->data(0, DefaultBitrateRole).canConvert(QVariant::String)) {
                 ui.default_vbitrate->setValue(item->data(0, DefaultBitrateRole).toInt());
             }
         }
     } else {
         ui.vbitrates->setHidden(true);
     }
 
     if (params.contains(QStringLiteral("%audiobitrate")) || ui.parameters->toPlainText().contains(QStringLiteral("%audioquality"))) {
         if (params.contains(QStringLiteral("%audioquality"))) {
             ui.abitrates_label->setText(i18n("Qualities"));
             ui.default_abitrate_label->setText(i18n("Default quality"));
         } else {
             ui.abitrates_label->setText(i18n("Bitrates"));
             ui.default_abitrate_label->setText(i18n("Default bitrate"));
         }
         if (item->data(0, AudioBitratesRole).canConvert(QVariant::StringList) && (item->data(0, AudioBitratesRole).toStringList().count() != 0)) {
             QStringList bitrates = item->data(0, AudioBitratesRole).toStringList();
             ui.abitrates_list->setText(bitrates.join(QLatin1Char(',')));
             if (item->data(0, DefaultAudioBitrateRole).canConvert(QVariant::String)) {
                 ui.default_abitrate->setValue(item->data(0, DefaultAudioBitrateRole).toInt());
             }
         }
     } else {
         ui.abitrates->setHidden(true);
     }
 
     if (item->data(0, SpeedsRole).canConvert(QVariant::StringList) && (item->data(0, SpeedsRole).toStringList().count() != 0)) {
         QStringList speeds = item->data(0, SpeedsRole).toStringList();
         ui.speeds_list->setText(speeds.join('\n'));
     }
 
     d->setWindowTitle(i18n("Edit Profile"));
 
     if (d->exec() == QDialog::Accepted) {
         slotDeleteProfile(true);
         QString exportFile = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/export/customprofiles.xml");
         QDomDocument doc;
         QFile file(exportFile);
         doc.setContent(&file, false);
         file.close();
         QDomElement documentElement;
         QDomElement profiles = doc.documentElement();
 
         if (profiles.isNull() || profiles.tagName() != QLatin1String("profiles")) {
             doc.clear();
             profiles = doc.createElement(QStringLiteral("profiles"));
             profiles.setAttribute(QStringLiteral("version"), 1);
             doc.appendChild(profiles);
         }
 
         int version = profiles.attribute(QStringLiteral("version"), nullptr).toInt();
         if (version < 1) {
             doc.clear();
             profiles = doc.createElement(QStringLiteral("profiles"));
             profiles.setAttribute(QStringLiteral("version"), 1);
             doc.appendChild(profiles);
         }
 
         QString newProfileName = ui.profile_name->text().simplified();
         QString newGroupName = ui.group_name->text().simplified();
         if (newGroupName.isEmpty()) {
             newGroupName = i18nc("Group Name", "Custom");
         }
         QDomNodeList profilelist = doc.elementsByTagName(QStringLiteral("profile"));
         int i = 0;
         while (!profilelist.item(i).isNull()) {
             // make sure a profile with same name doesn't exist
             documentElement = profilelist.item(i).toElement();
             QString profileName = documentElement.attribute(QStringLiteral("name"));
             if (profileName == newProfileName) {
                 // a profile with that same name already exists
                 bool ok;
                 newProfileName = QInputDialog::getText(this, i18n("Profile already exists"),
                                                        i18n("This profile name already exists. Change the name if you do not want to overwrite it."),
                                                        QLineEdit::Normal, newProfileName, &ok);
                 if (!ok) {
                     return;
                 }
                 if (profileName == newProfileName) {
                     profiles.removeChild(profilelist.item(i));
                     break;
                 }
             }
             ++i;
         }
 
         QDomElement profileElement = doc.createElement(QStringLiteral("profile"));
         profileElement.setAttribute(QStringLiteral("name"), newProfileName);
         profileElement.setAttribute(QStringLiteral("category"), newGroupName);
         profileElement.setAttribute(QStringLiteral("extension"), ui.extension->text().simplified());
         QString args = ui.parameters->toPlainText().simplified();
         profileElement.setAttribute(QStringLiteral("args"), args);
         if (args.contains(QStringLiteral("%bitrate"))) {
             // profile has a variable bitrate
             profileElement.setAttribute(QStringLiteral("defaultbitrate"), QString::number(ui.default_vbitrate->value()));
             profileElement.setAttribute(QStringLiteral("bitrates"), ui.vbitrates_list->text());
         } else if (args.contains(QStringLiteral("%quality"))) {
             profileElement.setAttribute(QStringLiteral("defaultquality"), QString::number(ui.default_vbitrate->value()));
             profileElement.setAttribute(QStringLiteral("qualities"), ui.vbitrates_list->text());
         }
         if (args.contains(QStringLiteral("%audiobitrate"))) {
             // profile has a variable bitrate
             profileElement.setAttribute(QStringLiteral("defaultaudiobitrate"), QString::number(ui.default_abitrate->value()));
             profileElement.setAttribute(QStringLiteral("audiobitrates"), ui.abitrates_list->text());
         } else if (args.contains(QStringLiteral("%audioquality"))) {
             profileElement.setAttribute(QStringLiteral("defaultaudioquality"), QString::number(ui.default_abitrate->value()));
             profileElement.setAttribute(QStringLiteral("audioqualities"), ui.abitrates_list->text());
         }
 
         QString speeds_list_str = ui.speeds_list->toPlainText();
         if (!speeds_list_str.isEmpty()) {
             // profile has a variable speed
             profileElement.setAttribute(QStringLiteral("speeds"), speeds_list_str.replace('\n', ';').simplified());
         }
 
         profiles.appendChild(profileElement);
 
         // QCString save = doc.toString().utf8();
         delete d;
         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
             KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
             return;
         }
         QTextStream out(&file);
         out << doc.toString();
         if (file.error() != QFile::NoError) {
             KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
             file.close();
             return;
         }
         file.close();
         parseProfiles();
     } else {
         delete d;
     }
 }
 
 void RenderWidget::slotDeleteProfile(bool dontRefresh)
 {
     // TODO: delete a profile installed by KNewStuff the easy way
     /*
     QString edit = m_view.formats->currentItem()->data(EditableRole).toString();
     if (!edit.endsWith(QLatin1String("customprofiles.xml"))) {
         // This is a KNewStuff installed file, process through KNS
         KNS::Engine engine(0);
         if (engine.init("kdenlive_render.knsrc")) {
             KNS::Entry::List entries;
         }
         return;
     }*/
     QTreeWidgetItem *item = m_view.formats->currentItem();
     if ((item == nullptr) || (item->parent() == nullptr)) {
         return;
     }
     QString currentProfile = item->text(0);
 
     QString exportFile = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/export/customprofiles.xml");
     QDomDocument doc;
     QFile file(exportFile);
     doc.setContent(&file, false);
     file.close();
 
     QDomElement documentElement;
     QDomNodeList profiles = doc.elementsByTagName(QStringLiteral("profile"));
     int i = 0;
     QString profileName;
     while (!profiles.item(i).isNull()) {
         documentElement = profiles.item(i).toElement();
         profileName = documentElement.attribute(QStringLiteral("name"));
         if (profileName == currentProfile) {
             doc.documentElement().removeChild(profiles.item(i));
             break;
         }
         ++i;
     }
     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         KMessageBox::sorry(this, i18n("Unable to write to file %1", exportFile));
         return;
     }
     QTextStream out(&file);
     out << doc.toString();
     if (file.error() != QFile::NoError) {
         KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
         file.close();
         return;
     }
     file.close();
     if (dontRefresh) {
         return;
     }
     parseProfiles();
     focusFirstVisibleItem();
 }
 
 void RenderWidget::updateButtons()
 {
     if ((m_view.formats->currentItem() == nullptr) || m_view.formats->currentItem()->isHidden()) {
         m_view.buttonSave->setEnabled(false);
         m_view.buttonDelete->setEnabled(false);
         m_view.buttonEdit->setEnabled(false);
         m_view.buttonRender->setEnabled(false);
         m_view.buttonGenerateScript->setEnabled(false);
     } else {
         m_view.buttonSave->setEnabled(true);
         m_view.buttonRender->setEnabled(m_view.formats->currentItem()->data(0, ErrorRole).isNull());
         m_view.buttonGenerateScript->setEnabled(m_view.formats->currentItem()->data(0, ErrorRole).isNull());
         QString edit = m_view.formats->currentItem()->data(0, EditableRole).toString();
         if (edit.isEmpty() || !edit.endsWith(QLatin1String("customprofiles.xml"))) {
             m_view.buttonDelete->setEnabled(false);
             m_view.buttonEdit->setEnabled(false);
         } else {
             m_view.buttonDelete->setEnabled(true);
             m_view.buttonEdit->setEnabled(true);
         }
     }
 }
 
 void RenderWidget::focusFirstVisibleItem(const QString &profile)
 {
     QTreeWidgetItem *item = nullptr;
     if (!profile.isEmpty()) {
         QList<QTreeWidgetItem *> items = m_view.formats->findItems(profile, Qt::MatchExactly | Qt::MatchRecursive);
         if (!items.isEmpty()) {
             item = items.constFirst();
         }
     }
     if (!item) {
         // searched profile not found in any category, select 1st available profile
         for (int i = 0; i < m_view.formats->topLevelItemCount(); ++i) {
             item = m_view.formats->topLevelItem(i);
             if (item->childCount() > 0) {
                 item = item->child(0);
                 break;
             }
         }
     }
     if (item) {
         m_view.formats->setCurrentItem(item);
         item->parent()->setExpanded(true);
         refreshParams();
     }
     updateButtons();
 }
 
 void RenderWidget::slotPrepareExport(bool delayedRendering, const QString &scriptPath)
 {
     Q_UNUSED(scriptPath)
     if (pCore->projectDuration() < 2) {
         // Empty project, don't attempt to render
         return;
     }
     if (!QFile::exists(KdenliveSettings::rendererpath())) {
         KMessageBox::sorry(this, i18n("Cannot find the melt program required for rendering (part of Mlt)"));
         return;
     }
 
     if (QFile::exists(m_view.out_file->url().toLocalFile())) {
         if (KMessageBox::warningYesNo(this, i18n("Output file already exists. Do you want to overwrite it?")) != KMessageBox::Yes) {
             return;
         }
     }
 
     QString chapterFile;
     if (m_view.create_chapter->isChecked()) {
         chapterFile = m_view.out_file->url().toLocalFile() + QStringLiteral(".dvdchapter");
     }
 
     // mantisbt 1051
     QDir dir(m_view.out_file->url().adjusted(QUrl::RemoveFilename).toLocalFile());
     if (!dir.exists() && !dir.mkpath(QStringLiteral("."))) {
         KMessageBox::sorry(this, i18n("The directory %1, could not be created.\nPlease make sure you have the required permissions.",
                                       m_view.out_file->url().adjusted(QUrl::RemoveFilename).toLocalFile()));
         return;
     }
 
     prepareRendering(delayedRendering, chapterFile);
 }
 
 void RenderWidget::prepareRendering(bool delayedRendering, const QString &chapterFile)
 {
     KdenliveDoc *project = pCore->currentDoc();
 
     // Save rendering profile to document
     QMap<QString, QString> renderProps;
     renderProps.insert(QStringLiteral("rendercategory"), m_view.formats->currentItem()->parent()->text(0));
     renderProps.insert(QStringLiteral("renderprofile"), m_view.formats->currentItem()->text(0));
     renderProps.insert(QStringLiteral("renderurl"), m_view.out_file->url().toLocalFile());
     renderProps.insert(QStringLiteral("renderzone"), QString::number(static_cast<int>(m_view.render_zone->isChecked())));
     renderProps.insert(QStringLiteral("renderguide"), QString::number(static_cast<int>(m_view.render_guide->isChecked())));
     renderProps.insert(QStringLiteral("renderstartguide"), QString::number(m_view.guide_start->currentIndex()));
     renderProps.insert(QStringLiteral("renderendguide"), QString::number(m_view.guide_end->currentIndex()));
     renderProps.insert(QStringLiteral("renderscanning"), QString::number(m_view.scanning_list->currentIndex()));
     renderProps.insert(QStringLiteral("renderfield"), QString::number(m_view.field_order->currentIndex()));
     int export_audio = 0;
     if (m_view.export_audio->checkState() == Qt::Checked) {
         export_audio = 2;
     } else if (m_view.export_audio->checkState() == Qt::Unchecked) {
         export_audio = 1;
     }
 
     renderProps.insert(QStringLiteral("renderexportaudio"), QString::number(export_audio));
     renderProps.insert(QStringLiteral("renderrescale"), QString::number(static_cast<int>(m_view.rescale->isChecked())));
     renderProps.insert(QStringLiteral("renderrescalewidth"), QString::number(m_view.rescale_width->value()));
     renderProps.insert(QStringLiteral("renderrescaleheight"), QString::number(m_view.rescale_height->value()));
     renderProps.insert(QStringLiteral("rendertcoverlay"), QString::number(static_cast<int>(m_view.tc_overlay->isChecked())));
     renderProps.insert(QStringLiteral("rendertctype"), QString::number(m_view.tc_type->currentIndex()));
     renderProps.insert(QStringLiteral("renderratio"), QString::number(static_cast<int>(m_view.rescale_keep->isChecked())));
     renderProps.insert(QStringLiteral("renderplay"), QString::number(static_cast<int>(m_view.play_after->isChecked())));
     renderProps.insert(QStringLiteral("rendertwopass"), QString::number(static_cast<int>(m_view.checkTwoPass->isChecked())));
     renderProps.insert(QStringLiteral("renderquality"), QString::number(m_view.video->value()));
     renderProps.insert(QStringLiteral("renderaudioquality"), QString::number(m_view.audio->value()));
     renderProps.insert(QStringLiteral("renderspeed"), QString::number(m_view.speed->value()));
 
     emit selectedRenderProfile(renderProps);
 
     QString playlistPath;
     QString mltSuffix(QStringLiteral(".mlt"));
     QList<QString> playlistPaths;
     QList<QString> trackNames;
     QString renderName;
 
     if (delayedRendering) {
         bool ok;
         renderName = QFileInfo(pCore->currentDoc()->url().toLocalFile()).fileName();
         if (renderName.isEmpty()) {
             renderName = i18n("export") + QStringLiteral(".mlt");
         } else {
             renderName = renderName.section(QLatin1Char('.'), 0, -2);
             renderName.append(QStringLiteral(".mlt"));
         }
         QDir projectFolder(pCore->currentDoc()->projectDataFolder());
         projectFolder.mkpath(QStringLiteral("kdenlive-renderqueue"));
         projectFolder.cd(QStringLiteral("kdenlive-renderqueue"));
         if (projectFolder.exists(renderName)) {
             int ix = 1;
             while (projectFolder.exists(renderName)) {
                 if (renderName.contains(QLatin1Char('-'))) {
                     renderName = renderName.section(QLatin1Char('-'), 0, -2);
                 } else {
                     renderName = renderName.section(QLatin1Char('.'), 0, -2);
                 }
                 renderName.append(QString("-%1.mlt").arg(ix));
                 ix++;
             }
         }
         renderName = renderName.section(QLatin1Char('.'), 0, -2);
         renderName = QInputDialog::getText(this, i18n("Delayed rendering"), i18n("Select a name for this rendering."), QLineEdit::Normal, renderName, &ok);
         if (!ok) {
             return;
         }
         if (!renderName.endsWith(QStringLiteral(".mlt"))) {
             renderName.append(QStringLiteral(".mlt"));
         }
         if (projectFolder.exists(renderName)) {
             if (KMessageBox::questionYesNo(this, i18n("File %1 already exists.\nDo you want to overwrite it?", renderName)) == KMessageBox::No) {
                 return;
             }
         }
         playlistPath = projectFolder.absoluteFilePath(renderName);
     } else {
         QTemporaryFile tmp(QDir::tempPath() + "/kdenlive-XXXXXX.mlt");
         if (!tmp.open()) {
             // Something went wrong
             return;
         }
         tmp.close();
         playlistPath = tmp.fileName();
     }
     int in = 0;
     int out;
     Monitor *pMon = pCore->getMonitor(Kdenlive::ProjectMonitor);
     bool zoneOnly = m_view.render_zone->isChecked();
     if (zoneOnly) {
         in = pMon->getZoneStart();
         out = pMon->getZoneEnd() - 1;
     } else {
         out = pCore->projectDuration() - 2;
     }
 
     QString playlistContent = pCore->projectManager()->projectSceneList(project->url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).toLocalFile());
     if (!chapterFile.isEmpty()) {
         QDomDocument doc;
         QDomElement chapters = doc.createElement(QStringLiteral("chapters"));
         chapters.setAttribute(QStringLiteral("fps"), pCore->getCurrentFps());
         doc.appendChild(chapters);
         const QList<CommentedTime> guidesList = project->getGuideModel()->getAllMarkers();
         for (int i = 0; i < guidesList.count(); i++) {
             const CommentedTime &c = guidesList.at(i);
             int time = c.time().frames(pCore->getCurrentFps());
             if (time >= in && time < out) {
                 if (zoneOnly) {
                     time = time - in;
                 }
             }
             QDomElement chapter = doc.createElement(QStringLiteral("chapter"));
             chapters.appendChild(chapter);
             chapter.setAttribute(QStringLiteral("title"), c.comment());
             chapter.setAttribute(QStringLiteral("time"), time);
         }
         if (!chapters.childNodes().isEmpty()) {
             if (!project->getGuideModel()->hasMarker(out)) {
                 // Always insert a guide in pos 0
                 QDomElement chapter = doc.createElement(QStringLiteral("chapter"));
                 chapters.insertBefore(chapter, QDomNode());
                 chapter.setAttribute(QStringLiteral("title"), i18nc("the first in a list of chapters", "Start"));
                 chapter.setAttribute(QStringLiteral("time"), QStringLiteral("0"));
             }
             // save chapters file
             QFile file(chapterFile);
             if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                 qCWarning(KDENLIVE_LOG) << "//////  ERROR writing DVD CHAPTER file: " << chapterFile;
             } else {
                 file.write(doc.toString().toUtf8());
                 if (file.error() != QFile::NoError) {
                     qCWarning(KDENLIVE_LOG) << "//////  ERROR writing DVD CHAPTER file: " << chapterFile;
                 }
                 file.close();
             }
         }
     }
 
     // Set playlist audio volume to 100%
     QDomDocument doc;
     doc.setContent(playlistContent);
     QDomElement tractor = doc.documentElement().firstChildElement(QStringLiteral("tractor"));
     if (!tractor.isNull()) {
         QDomNodeList props = tractor.elementsByTagName(QStringLiteral("property"));
         for (int i = 0; i < props.count(); ++i) {
             if (props.at(i).toElement().attribute(QStringLiteral("name")) == QLatin1String("meta.volume")) {
                 props.at(i).firstChild().setNodeValue(QStringLiteral("1"));
                 break;
             }
         }
     }
 
     // Add autoclose to playlists.
     QDomNodeList playlists = doc.elementsByTagName(QStringLiteral("playlist"));
     for (int i = 0; i < playlists.length(); ++i) {
         playlists.item(i).toElement().setAttribute(QStringLiteral("autoclose"), 1);
     }
 
     // Do we want proxy rendering
     if (project->useProxy() && !proxyRendering()) {
         QString root = doc.documentElement().attribute(QStringLiteral("root"));
         if (!root.isEmpty() && !root.endsWith(QLatin1Char('/'))) {
             root.append(QLatin1Char('/'));
         }
 
         // replace proxy clips with originals
         QMap<QString, QString> proxies = pCore->projectItemModel()->getProxies(pCore->currentDoc()->documentRoot());
 
         QDomNodeList producers = doc.elementsByTagName(QStringLiteral("producer"));
         QString producerResource;
         QString producerService;
         QString suffix;
         QString prefix;
         for (int n = 0; n < producers.length(); ++n) {
             QDomElement e = producers.item(n).toElement();
             producerResource = Xml::getXmlProperty(e, QStringLiteral("resource"));
             producerService = Xml::getXmlProperty(e, QStringLiteral("mlt_service"));
             if (producerResource.isEmpty() || producerService == QLatin1String("color")) {
                 continue;
             }
             if (producerService == QLatin1String("timewarp")) {
                 // slowmotion producer
                 prefix = producerResource.section(QLatin1Char(':'), 0, 0) + QLatin1Char(':');
                 producerResource = producerResource.section(QLatin1Char(':'), 1);
             } else {
                 prefix.clear();
             }
             if (producerService == QLatin1String("framebuffer")) {
                 // slowmotion producer
                 suffix = QLatin1Char('?') + producerResource.section(QLatin1Char('?'), 1);
                 producerResource = producerResource.section(QLatin1Char('?'), 0, 0);
             } else {
                 suffix.clear();
             }
             if (!producerResource.isEmpty()) {
                 if (QFileInfo(producerResource).isRelative()) {
                     producerResource.prepend(root);
                 }
                 if (proxies.contains(producerResource)) {
                     QString replacementResource = proxies.value(producerResource);
                     Xml::setXmlProperty(e, QStringLiteral("resource"), prefix + replacementResource + suffix);
                     if (producerService == QLatin1String("timewarp")) {
                         Xml::setXmlProperty(e, QStringLiteral("warp_resource"), replacementResource);
                     }
                     // We need to delete the "aspect_ratio" property because proxy clips
                     // sometimes have different ratio than original clips
                     Xml::removeXmlProperty(e, QStringLiteral("aspect_ratio"));
                     Xml::removeMetaProperties(e);
                 }
             }
         }
     }
     generateRenderFiles(doc, playlistPath, in, out, delayedRendering);
 }
 
 void RenderWidget::generateRenderFiles(QDomDocument doc, const QString &playlistPath, int in, int out, bool delayedRendering)
 {
     QDomDocument clone;
     KdenliveDoc *project = pCore->currentDoc();
     int passes = m_view.checkTwoPass->isChecked() ? 2 : 1;
     QString renderArgs = m_view.advanced_params->toPlainText().simplified();
     QDomElement consumer = doc.createElement(QStringLiteral("consumer"));
     QDomNodeList profiles = doc.elementsByTagName(QStringLiteral("profile"));
     if (profiles.isEmpty()) {
         doc.documentElement().insertAfter(consumer, doc.documentElement());
     } else {
         doc.documentElement().insertAfter(consumer, profiles.at(profiles.length() - 1));
     }
 
     std::unique_ptr<ProfileModel> &profile = pCore->getCurrentProfile();
     if (renderArgs.contains(QLatin1String("%dv_standard"))) {
         QString dvstd;
         if (fmod(double(profile->frame_rate_num() / profile->frame_rate_den()), 30.01) > 27) {
             dvstd = QStringLiteral("ntsc");
         } else {
             dvstd = QStringLiteral("pal");
         }
         if (double(profile->display_aspect_num() / profile->display_aspect_den()) > 1.5) {
             dvstd += QLatin1String("_wide");
         }
         renderArgs.replace(QLatin1String("%dv_standard"), dvstd);
     }
 
     QStringList args = renderArgs.split(QLatin1Char(' '));
     for (auto &param : args) {
         if (param.contains(QLatin1Char('='))) {
             QString paramValue = param.section(QLatin1Char('='), 1);
             if (paramValue.startsWith(QLatin1Char('%'))) {
                 if (paramValue.startsWith(QStringLiteral("%bitrate")) || paramValue == QStringLiteral("%quality")) {
                     if (paramValue.contains("+'k'"))
                         paramValue = QString::number(m_view.video->value()) + 'k';
                     else
                         paramValue = QString::number(m_view.video->value());
                 }
                 if (paramValue.startsWith(QStringLiteral("%audiobitrate")) || paramValue == QStringLiteral("%audioquality")) {
                     if (paramValue.contains("+'k'"))
                         paramValue = QString::number(m_view.audio->value()) + 'k';
                     else
                         paramValue = QString::number(m_view.audio->value());
                 }
                 if (paramValue == QStringLiteral("%dar"))
                     paramValue = '@' + QString::number(profile->display_aspect_num()) + QLatin1Char('/') + QString::number(profile->display_aspect_den());
                 if (paramValue == QStringLiteral("%passes")) paramValue = QString::number(static_cast<int>(m_view.checkTwoPass->isChecked()) + 1);
             }
             consumer.setAttribute(param.section(QLatin1Char('='), 0, 0), paramValue);
         }
     }
 
     // Check for movit
     if (KdenliveSettings::gpu_accel()) {
         consumer.setAttribute(QStringLiteral("glsl."), 1);
     }
 
     // in/out points
     if (m_view.render_guide->isChecked()) {
         double fps = profile->fps();
         double guideStart = m_view.guide_start->itemData(m_view.guide_start->currentIndex()).toDouble();
         double guideEnd = m_view.guide_end->itemData(m_view.guide_end->currentIndex()).toDouble();
         consumer.setAttribute(QStringLiteral("in"), int(GenTime(guideStart).frames(fps)));
         consumer.setAttribute(QStringLiteral("out"), int(GenTime(guideEnd).frames(fps)));
     } else {
         consumer.setAttribute(QStringLiteral("in"), in);
         consumer.setAttribute(QStringLiteral("out"), out);
     }
 
     // Check if the rendering profile is different from project profile,
     // in which case we need to use the producer_comsumer from MLT
     QString subsize;
     if (renderArgs.startsWith(QLatin1String("s="))) {
         subsize = renderArgs.section(QLatin1Char(' '), 0, 0).toLower();
         subsize = subsize.section(QLatin1Char('='), 1, 1);
     } else if (renderArgs.contains(QStringLiteral(" s="))) {
         subsize = renderArgs.section(QStringLiteral(" s="), 1, 1);
         subsize = subsize.section(QLatin1Char(' '), 0, 0).toLower();
     } else if (m_view.rescale->isChecked() && m_view.rescale->isEnabled()) {
         subsize = QStringLiteral("%1x%2").arg(m_view.rescale_width->value()).arg(m_view.rescale_height->value());
     }
     if (!subsize.isEmpty()) {
         consumer.setAttribute(QStringLiteral("s"), subsize);
     }
 
     // Project metadata
     if (m_view.export_meta->isChecked()) {
         QMap<QString, QString> metadata = project->metadata();
         QMap<QString, QString>::const_iterator i = metadata.constBegin();
         while (i != metadata.constEnd()) {
             consumer.setAttribute(i.key(), i.value());
             ++i;
         }
     }
 
     // Adjust encoding speed
     if (m_view.speed->isEnabled() && m_view.formats->currentItem()) {
         QStringList speeds = m_view.formats->currentItem()->data(0, SpeedsRole).toStringList();
         if (m_view.speed->value() < speeds.count()) {
             QString speedValue = speeds.at(m_view.speed->value());
             if (speedValue.contains(QLatin1Char('='))) {
                 consumer.setAttribute(speedValue.section(QLatin1Char('='), 0, 0), speedValue.section(QLatin1Char('='), 1));
             }
         }
     }
 
     // Adjust scanning
     switch (m_view.scanning_list->currentIndex()) {
     case 1:
         consumer.setAttribute(QStringLiteral("progressive"), 1);
         break;
     case 2:
         // Interlaced rendering
         consumer.setAttribute(QStringLiteral("progressive"), 0);
         // Adjust field order
         consumer.setAttribute(QStringLiteral("top_field_first"), m_view.field_order->currentIndex());
         break;
     default:
         // leave as is
         break;
     }
 
     // check if audio export is selected
     bool exportAudio;
     if (automaticAudioExport()) {
         // TODO check if projact contains audio
         // exportAudio = pCore->projectManager()->currentTimeline()->checkProjectAudio();
         exportAudio = true;
     } else {
         exportAudio = selectedAudioExport();
     }
 
     if (renderArgs.contains(QLatin1String("pix_fmt=argb"))
      || renderArgs.contains(QLatin1String("pix_fmt=abgr"))
      || renderArgs.contains(QLatin1String("pix_fmt=bgra"))
      || renderArgs.contains(QLatin1String("pix_fmt=gbra"))
      || renderArgs.contains(QLatin1String("pix_fmt=rgba"))
      || renderArgs.contains(QLatin1String("pix_fmt=yuva"))
      || renderArgs.contains(QLatin1String("pix_fmt=ya"  ))
      || renderArgs.contains(QLatin1String("pix_fmt=ayuv"))) {
         auto prods = doc.elementsByTagName(QStringLiteral("producer"));
         for (int i = 0; i < prods.count(); ++i) {
             auto prod = prods.at(i).toElement();
             if (prod.attribute(QStringLiteral("id")) == QStringLiteral("black_track")) {
                 Xml::setXmlProperty(prod, QStringLiteral("resource"), QStringLiteral("transparent"));
                 break;
             }
         }
     }
 
     // disable audio if requested
     if (!exportAudio) {
         consumer.setAttribute(QStringLiteral("an"), 1);
     }
 
     int threadCount = QThread::idealThreadCount();
     if (threadCount < 2 || !m_view.parallel_process->isChecked() || !m_view.parallel_process->isEnabled()) {
         threadCount = 1;
     } else {
         threadCount = qMin(4, threadCount - 1);
     }
 
     // Set the thread counts
     if (!renderArgs.contains(QStringLiteral("threads="))) {
         consumer.setAttribute(QStringLiteral("threads"), KdenliveSettings::encodethreads());
     }
     consumer.setAttribute(QStringLiteral("real_time"), -threadCount);
 
     // check which audio tracks have to be exported
     /*if (stemExport) {
         // TODO refac
         //TODO port to new timeline model
         Timeline *ct = pCore->projectManager()->currentTimeline();
         int allTracksCount = ct->tracksCount();
 
         // reset tracks count (tracks to be rendered)
         tracksCount = 0;
         // begin with track 1 (track zero is a hidden black track)
         for (int i = 1; i < allTracksCount; i++) {
             Track *track = ct->track(i);
             // add only tracks to render list that are not muted and have audio
             if ((track != nullptr) && !track->info().isMute && track->hasAudio()) {
                 QDomDocument docCopy = doc.cloneNode(true).toDocument();
                 QString trackName = track->info().trackName;
 
                 // save track name
                 trackNames << trackName;
                 qCDebug(KDENLIVE_LOG) << "Track-Name: " << trackName;
 
                 // create stem export doc content
                 QDomNodeList tracks = docCopy.elementsByTagName(QStringLiteral("track"));
                 for (int j = 0; j < allTracksCount; j++) {
                     if (j != i) {
                         // mute other tracks
                         tracks.at(j).toElement().setAttribute(QStringLiteral("hide"), QStringLiteral("both"));
                     }
                 }
                 docList << docCopy;
                 tracksCount++;
             }
         }
     }*/
 
     if (m_view.checkTwoPass->isChecked()) {
         // We will generate 2 files, one for each pass.
         clone = doc.cloneNode(true).toDocument();
     }
     QStringList playlists;
     QString renderedFile = m_view.out_file->url().toLocalFile();
     for (int i = 0; i < passes; i++) {
         // Append consumer settings
         QDomDocument final = i > 0 ? clone : doc;
         QDomNodeList cons = final.elementsByTagName(QStringLiteral("consumer"));
         QDomElement myConsumer = cons.at(0).toElement();
         QString mytarget = renderedFile;
         QString playlistName = playlistPath;
         myConsumer.setAttribute(QStringLiteral("mlt_service"), QStringLiteral("avformat"));
         if (passes == 2 && i == 1) {
             playlistName = playlistName.section(QLatin1Char('.'), 0, -2) + QString("-pass%1.").arg(i + 1) + playlistName.section(QLatin1Char('.'), -1);
         }
         playlists << playlistName;
         myConsumer.setAttribute(QStringLiteral("target"), mytarget);
 
         // Prepare rendering args
         int pass = passes == 2 ? i + 1 : 0;
         if (renderArgs.contains(QStringLiteral("libx265"))) {
             if (pass == 1 || pass == 2) {
                 QString x265params = myConsumer.attribute("x265-params");
                 x265params = QString("pass=%1:stats=%2:%3").arg(pass).arg(mytarget.replace(":", "\\:") + "_2pass.log").arg(x265params);
                 myConsumer.setAttribute("x265-params", x265params);
             }
         } else {
             if (pass == 1 || pass == 2) {
                 myConsumer.setAttribute("pass", pass);
                 myConsumer.setAttribute("passlogfile", mytarget + "_2pass.log");
             }
             if (pass == 1) {
                 myConsumer.setAttribute("fastfirstpass", 1);
                 myConsumer.removeAttribute("acodec");
                 myConsumer.setAttribute("an", 1);
             } else {
                 myConsumer.removeAttribute("fastfirstpass");
             }
         }
         QFile file(playlistName);
         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
             pCore->displayMessage(i18n("Cannot write to file %1", playlistName), ErrorMessage);
             return;
         }
         file.write(final.toString().toUtf8());
         if (file.error() != QFile::NoError) {
             pCore->displayMessage(i18n("Cannot write to file %1", playlistName), ErrorMessage);
             file.close();
             return;
         }
         file.close();
     }
 
     // Create job
     RenderJobItem *renderItem = nullptr;
     QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(renderedFile, Qt::MatchExactly, 1);
     if (!existing.isEmpty()) {
         renderItem = static_cast<RenderJobItem *>(existing.at(0));
         if (renderItem->status() == RUNNINGJOB || renderItem->status() == WAITINGJOB || renderItem->status() == STARTINGJOB) {
             KMessageBox::information(
                 this, i18n("There is already a job writing file:<br /><b>%1</b><br />Abort the job if you want to overwrite it...", renderedFile),
                 i18n("Already running"));
             return;
         }
         if (delayedRendering || playlists.size() > 1) {
             delete renderItem;
             renderItem = nullptr;
         } else {
             renderItem->setData(1, ProgressRole, 0);
             renderItem->setStatus(WAITINGJOB);
             renderItem->setIcon(0, QIcon::fromTheme(QStringLiteral("media-playback-pause")));
             renderItem->setData(1, Qt::UserRole, i18n("Waiting..."));
             QStringList argsJob = {KdenliveSettings::rendererpath(), playlistPath, renderedFile,
                                    QStringLiteral("-pid:%1").arg(QCoreApplication::applicationPid())};
             renderItem->setData(1, ParametersRole, argsJob);
             renderItem->setData(1, TimeRole, QDateTime::currentDateTime());
             if (!exportAudio) {
                 renderItem->setData(1, ExtraInfoRole, i18n("Video without audio track"));
             } else {
                 renderItem->setData(1, ExtraInfoRole, QString());
             }
             m_view.running_jobs->setCurrentItem(renderItem);
             m_view.tabWidget->setCurrentIndex(1);
             checkRenderStatus();
             return;
         }
     }
     if (delayedRendering) {
         parseScriptFiles();
         return;
     }
     QList<RenderJobItem *> jobList;
     for (const QString &pl : playlists) {
         renderItem = new RenderJobItem(m_view.running_jobs, QStringList() << QString() << renderedFile);
         renderItem->setData(1, TimeRole, QDateTime::currentDateTime());
         QStringList argsJob = {KdenliveSettings::rendererpath(), pl, renderedFile, QStringLiteral("-pid:%1").arg(QCoreApplication::applicationPid())};
         renderItem->setData(1, ParametersRole, argsJob);
         qDebug() << "* CREATED JOB WITH ARGS: " << argsJob;
         if (!exportAudio) {
             renderItem->setData(1, ExtraInfoRole, i18n("Video without audio track"));
         } else {
             renderItem->setData(1, ExtraInfoRole, QString());
         }
         jobList << renderItem;
     }
 
     m_view.running_jobs->setCurrentItem(jobList.at(0));
     m_view.tabWidget->setCurrentIndex(1);
     // check render status
     checkRenderStatus();
 
     // create full playlistPaths
     /*for (int i = 0; i < tracksCount; i++) {
         QString plPath(playlistPath);
 
         // add track number to path name
         if (stemExport) {
             plPath = plPath + QLatin1Char('_') + QString(trackNames.at(i)).replace(QLatin1Char(' '), QLatin1Char('_'));
         }
         // add mlt suffix
         if (!plPath.endsWith(mltSuffix)) {
             plPath += mltSuffix;
         }
         playlistPaths << plPath;
         qCDebug(KDENLIVE_LOG) << "playlistPath: " << plPath << endl;
 
         // Do save scenelist
         QFile file(plPath);
         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
             pCore->displayMessage(i18n("Cannot write to file %1", plPath), ErrorMessage);
             return;
         }
         file.write(docList.at(i).toString().toUtf8());
         if (file.error() != QFile::NoError) {
             pCore->displayMessage(i18n("Cannot write to file %1", plPath), ErrorMessage);
             file.close();
             return;
         }
         file.close();
     }*/
     // slotExport(delayedRendering, in, out, project->metadata(), playlistPaths, trackNames, renderName, exportAudio);
 }
 
 void RenderWidget::checkRenderStatus()
 {
     // check if we have a job waiting to render
     if (m_blockProcessing) {
         return;
     }
 
     auto *item = static_cast<RenderJobItem *>(m_view.running_jobs->topLevelItem(0));
 
     // Make sure no other rendering is running
     while (item != nullptr) {
         if (item->status() == RUNNINGJOB) {
             return;
         }
         item = static_cast<RenderJobItem *>(m_view.running_jobs->itemBelow(item));
     }
     item = static_cast<RenderJobItem *>(m_view.running_jobs->topLevelItem(0));
     bool waitingJob = false;
 
     // Find first waiting job
     while (item != nullptr) {
         if (item->status() == WAITINGJOB) {
             item->setData(1, TimeRole, QDateTime::currentDateTime());
             waitingJob = true;
             startRendering(item);
             // Check for 2 pass encoding
             QStringList jobData = item->data(1, ParametersRole).toStringList();
             if (jobData.size() > 2 && jobData.at(1).endsWith(QStringLiteral("-pass2.mlt"))) {
                 // Find and remove 1st pass job
                 QTreeWidgetItem *above = m_view.running_jobs->itemAbove(item);
                 QString firstPassName = jobData.at(1).section(QLatin1Char('-'), 0, -2) + QStringLiteral(".mlt");
                 while (above) {
                     QStringList aboveData = above->data(1, ParametersRole).toStringList();
                     qDebug() << "// GOT  JOB: " << aboveData.at(1);
                     if (aboveData.size() > 2 && aboveData.at(1) == firstPassName) {
                         delete above;
                         break;
                     }
                     above = m_view.running_jobs->itemAbove(above);
                 }
             }
             item->setStatus(STARTINGJOB);
             break;
         }
         item = static_cast<RenderJobItem *>(m_view.running_jobs->itemBelow(item));
     }
     if (!waitingJob && m_view.shutdown->isChecked()) {
         emit shutdown();
     }
 }
 
 void RenderWidget::startRendering(RenderJobItem *item)
 {
     auto rendererArgs = item->data(1, ParametersRole).toStringList();
     qDebug() << "starting kdenlive_render process using: " << m_renderer;
     if (!QProcess::startDetached(m_renderer, rendererArgs)) {
         item->setStatus(FAILEDJOB);
     } else {
         KNotification::event(QStringLiteral("RenderStarted"), i18n("Rendering <i>%1</i> started", item->text(1)), QPixmap(), this);
     }
 }
 
 int RenderWidget::waitingJobsCount() const
 {
     int count = 0;
     auto *item = static_cast<RenderJobItem *>(m_view.running_jobs->topLevelItem(0));
     while (item != nullptr) {
         if (item->status() == WAITINGJOB || item->status() == STARTINGJOB) {
             count++;
         }
         item = static_cast<RenderJobItem *>(m_view.running_jobs->itemBelow(item));
     }
     return count;
 }
 
 void RenderWidget::adjustViewToProfile()
 {
     m_view.scanning_list->setCurrentIndex(0);
     m_view.rescale_width->setValue(KdenliveSettings::defaultrescalewidth());
     if (!m_view.rescale_keep->isChecked()) {
         m_view.rescale_height->blockSignals(true);
         m_view.rescale_height->setValue(KdenliveSettings::defaultrescaleheight());
         m_view.rescale_height->blockSignals(false);
     }
     refreshView();
 }
 
 void RenderWidget::refreshView()
 {
     m_view.formats->blockSignals(true);
     QIcon brokenIcon = QIcon::fromTheme(QStringLiteral("dialog-close"));
     QIcon warningIcon = QIcon::fromTheme(QStringLiteral("dialog-warning"));
 
     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
     const QColor disabled = scheme.foreground(KColorScheme::InactiveText).color();
     const QColor disabledbg = scheme.background(KColorScheme::NegativeBackground).color();
 
     // We borrow a reference to the profile's pointer to query it more easily
     std::unique_ptr<ProfileModel> &profile = pCore->getCurrentProfile();
     double project_framerate = double(profile->frame_rate_num()) / profile->frame_rate_den();
     for (int i = 0; i < m_view.formats->topLevelItemCount(); ++i) {
         QTreeWidgetItem *group = m_view.formats->topLevelItem(i);
         for (int j = 0; j < group->childCount(); ++j) {
             QTreeWidgetItem *item = group->child(j);
             QString std = item->data(0, StandardRole).toString();
             if (std.isEmpty() ||
                 (std.contains(QStringLiteral("PAL"), Qt::CaseInsensitive) && profile->frame_rate_num() == 25 && profile->frame_rate_den() == 1) ||
                 (std.contains(QStringLiteral("NTSC"), Qt::CaseInsensitive) && profile->frame_rate_num() == 30000 && profile->frame_rate_den() == 1001)) {
                 // Standard OK
             } else {
                 item->setData(0, ErrorRole, i18n("Standard (%1) not compatible with project profile (%2)", std, project_framerate));
                 item->setIcon(0, brokenIcon);
                 item->setForeground(0, disabled);
                 continue;
             }
             QString params = item->data(0, ParamsRole).toString();
             // Make sure the selected profile uses the same frame rate as project profile
             if (params.contains(QStringLiteral("mlt_profile="))) {
                 QString profile_str = params.section(QStringLiteral("mlt_profile="), 1, 1).section(QLatin1Char(' '), 0, 0);
                 std::unique_ptr<ProfileModel> &target_profile = ProfileRepository::get()->getProfile(profile_str);
                 if (target_profile->frame_rate_den() > 0) {
                     double profile_rate = double(target_profile->frame_rate_num()) / target_profile->frame_rate_den();
                     if (int(1000.0 * profile_rate) != int(1000.0 * project_framerate)) {
                         item->setData(0, ErrorRole, i18n("Frame rate (%1) not compatible with project profile (%2)", profile_rate, project_framerate));
                         item->setIcon(0, brokenIcon);
                         item->setForeground(0, disabled);
                         continue;
                     }
                 }
             }
 
             // Make sure the selected profile uses an installed avformat codec / format
             if (!supportedFormats.isEmpty()) {
                 QString format;
                 if (params.startsWith(QLatin1String("f="))) {
                     format = params.section(QStringLiteral("f="), 1, 1);
                 } else if (params.contains(QStringLiteral(" f="))) {
                     format = params.section(QStringLiteral(" f="), 1, 1);
                 }
                 if (!format.isEmpty()) {
                     format = format.section(QLatin1Char(' '), 0, 0).toLower();
                     if (!supportedFormats.contains(format)) {
                         item->setData(0, ErrorRole, i18n("Unsupported video format: %1", format));
                         item->setIcon(0, brokenIcon);
                         item->setForeground(0, disabled);
                         continue;
                     }
                 }
             }
             if (!acodecsList.isEmpty()) {
                 QString format;
                 if (params.startsWith(QLatin1String("acodec="))) {
                     format = params.section(QStringLiteral("acodec="), 1, 1);
                 } else if (params.contains(QStringLiteral(" acodec="))) {
                     format = params.section(QStringLiteral(" acodec="), 1, 1);
                 }
                 if (!format.isEmpty()) {
                     format = format.section(QLatin1Char(' '), 0, 0).toLower();
                     if (!acodecsList.contains(format)) {
                         item->setData(0, ErrorRole, i18n("Unsupported audio codec: %1", format));
                         item->setIcon(0, brokenIcon);
                         item->setForeground(0, disabled);
                         item->setBackground(0, disabledbg);
                     }
                 }
             }
             if (!vcodecsList.isEmpty()) {
                 QString format;
                 if (params.startsWith(QLatin1String("vcodec="))) {
                     format = params.section(QStringLiteral("vcodec="), 1, 1);
                 } else if (params.contains(QStringLiteral(" vcodec="))) {
                     format = params.section(QStringLiteral(" vcodec="), 1, 1);
                 }
                 if (!format.isEmpty()) {
                     format = format.section(QLatin1Char(' '), 0, 0).toLower();
                     if (!vcodecsList.contains(format)) {
                         item->setData(0, ErrorRole, i18n("Unsupported video codec: %1", format));
                         item->setIcon(0, brokenIcon);
                         item->setForeground(0, disabled);
                         continue;
                     }
                 }
             }
             if (params.contains(QStringLiteral(" profile=")) || params.startsWith(QLatin1String("profile="))) {
                 // changed in MLT commit d8a3a5c9190646aae72048f71a39ee7446a3bd45
                 // (https://github.com/mltframework/mlt/commit/d8a3a5c9190646aae72048f71a39ee7446a3bd45)
                 item->setData(0, ErrorRole,
                               i18n("This render profile uses a 'profile' parameter.<br />Unless you know what you are doing you will probably "
                                    "have to change it to 'mlt_profile'."));
                 item->setIcon(0, warningIcon);
                 continue;
             }
         }
     }
     focusFirstVisibleItem();
     m_view.formats->blockSignals(false);
     refreshParams();
 }
 
 QUrl RenderWidget::filenameWithExtension(QUrl url, const QString &extension)
 {
     if (!url.isValid()) {
         url = QUrl::fromLocalFile(pCore->currentDoc()->projectDataFolder() + QDir::separator());
     }
     QString directory = url.adjusted(QUrl::RemoveFilename).toLocalFile();
     QString filename = url.fileName();
     if (filename.isEmpty()) {
         filename = pCore->currentDoc()->url().fileName();
     }
     QString ext;
 
     if (extension.at(0) == '.') {
         ext = extension;
     } else {
         ext = '.' + extension;
     }
 
     if (filename.isEmpty()) {
         filename = i18n("untitled");
     }
 
     int pos = filename.lastIndexOf('.');
     if (pos == 0) {
         filename.append(ext);
     } else {
         if (!filename.endsWith(ext, Qt::CaseInsensitive)) {
             filename = filename.left(pos) + ext;
         }
     }
 
     return QUrl::fromLocalFile(directory + filename);
 }
 
 void RenderWidget::refreshParams()
 {
     // Format not available (e.g. codec not installed); Disable start button
     QTreeWidgetItem *item = m_view.formats->currentItem();
     if ((item == nullptr) || item->parent() == nullptr) {
         // This is a category item, not a real profile
         m_view.buttonBox->setEnabled(false);
     } else {
         m_view.buttonBox->setEnabled(true);
     }
     QString extension;
     if (item) {
         extension = item->data(0, ExtensionRole).toString();
     }
     if ((item == nullptr) || item->isHidden() || extension.isEmpty()) {
         if (!item) {
             errorMessage(ProfileError, i18n("No matching profile"));
         } else if (!item->parent()) // category
             ;
         else if (extension.isEmpty()) {
             errorMessage(ProfileError, i18n("Invalid profile"));
         }
         m_view.advanced_params->clear();
         m_view.buttonRender->setEnabled(false);
         m_view.buttonGenerateScript->setEnabled(false);
         return;
     }
     QString params = item->data(0, ParamsRole).toString();
     errorMessage(ProfileError, item->data(0, ErrorRole).toString());
     m_view.advanced_params->setPlainText(params);
     if (params.contains(QStringLiteral(" s=")) || params.startsWith(QLatin1String("s=")) || params.contains(QLatin1String("%dv_standard"))) {
         // profile has a fixed size, do not allow resize
         m_view.rescale->setEnabled(false);
         setRescaleEnabled(false);
     } else {
         m_view.rescale->setEnabled(true);
         setRescaleEnabled(m_view.rescale->isChecked());
     }
     QUrl url = filenameWithExtension(m_view.out_file->url(), extension);
     m_view.out_file->setUrl(url);
     //     if (!url.isEmpty()) {
     //         QString path = url.path();
     //         int pos = path.lastIndexOf('.') + 1;
     //  if (pos == 0) path.append('.' + extension);
     //         else path = path.left(pos) + extension;
     //         m_view.out_file->setUrl(QUrl(path));
     //     } else {
     //         m_view.out_file->setUrl(QUrl(QDir::homePath() + QStringLiteral("/untitled.") + extension));
     //     }
     m_view.out_file->setFilter("*." + extension);
     QString edit = item->data(0, EditableRole).toString();
     if (edit.isEmpty() || !edit.endsWith(QLatin1String("customprofiles.xml"))) {
         m_view.buttonDelete->setEnabled(false);
         m_view.buttonEdit->setEnabled(false);
     } else {
         m_view.buttonDelete->setEnabled(true);
         m_view.buttonEdit->setEnabled(true);
     }
 
     // video quality control
     m_view.video->blockSignals(true);
     bool quality = false;
     if ((params.contains(QStringLiteral("%quality")) || params.contains(QStringLiteral("%bitrate"))) &&
         item->data(0, BitratesRole).canConvert(QVariant::StringList)) {
         // bitrates or quantizers list
         QStringList qs = item->data(0, BitratesRole).toStringList();
         if (qs.count() > 1) {
             quality = true;
             int qmax = qs.constFirst().toInt();
             int qmin = qs.last().toInt();
             if (qmax < qmin) {
                 // always show best quality on right
                 m_view.video->setRange(qmax, qmin);
                 m_view.video->setProperty("decreasing", true);
             } else {
                 m_view.video->setRange(qmin, qmax);
                 m_view.video->setProperty("decreasing", false);
             }
         }
     }
     m_view.video->setEnabled(quality);
     m_view.quality->setEnabled(quality);
     m_view.qualityLabel->setEnabled(quality);
     m_view.video->blockSignals(false);
 
     // audio quality control
     quality = false;
     m_view.audio->blockSignals(true);
     if ((params.contains(QStringLiteral("%audioquality")) || params.contains(QStringLiteral("%audiobitrate"))) &&
         item->data(0, AudioBitratesRole).canConvert(QVariant::StringList)) {
         // bitrates or quantizers list
         QStringList qs = item->data(0, AudioBitratesRole).toStringList();
         if (qs.count() > 1) {
             quality = true;
             int qmax = qs.constFirst().toInt();
             int qmin = qs.last().toInt();
             if (qmax < qmin) {
                 m_view.audio->setRange(qmax, qmin);
                 m_view.audio->setProperty("decreasing", true);
             } else {
                 m_view.audio->setRange(qmin, qmax);
                 m_view.audio->setProperty("decreasing", false);
             }
             if (params.contains(QStringLiteral("%audiobitrate"))) {
                 m_view.audio->setSingleStep(32); // 32kbps step
             } else {
                 m_view.audio->setSingleStep(1);
             }
         }
     }
     m_view.audio->setEnabled(quality);
     m_view.audio->blockSignals(false);
     if (m_view.quality->isEnabled()) {
         adjustAVQualities(m_view.quality->value());
     }
 
     if (item->data(0, SpeedsRole).canConvert(QVariant::StringList) && (item->data(0, SpeedsRole).toStringList().count() != 0)) {
         int speed = item->data(0, SpeedsRole).toStringList().count() - 1;
         m_view.speed->setEnabled(true);
         m_view.speed->setMaximum(speed);
         m_view.speed->setValue(speed * 3 / 4); // default to intermediate speed
     } else {
         m_view.speed->setEnabled(false);
     }
     if (!item->data(0, FieldRole).isNull()) {
         m_view.field_order->setCurrentIndex(item->data(0, FieldRole).toInt());
     }
     adjustSpeed(m_view.speed->value());
     bool passes = params.contains(QStringLiteral("passes"));
     m_view.checkTwoPass->setEnabled(passes);
     m_view.checkTwoPass->setChecked(passes && params.contains(QStringLiteral("passes=2")));
 
     m_view.encoder_threads->setEnabled(!params.contains(QStringLiteral("threads=")));
 
     m_view.buttonRender->setEnabled(m_view.formats->currentItem()->data(0, ErrorRole).isNull());
     m_view.buttonGenerateScript->setEnabled(m_view.formats->currentItem()->data(0, ErrorRole).isNull());
 }
 
 void RenderWidget::reloadProfiles()
 {
     parseProfiles();
 }
 
 void RenderWidget::parseProfiles(const QString &selectedProfile)
 {
     m_view.formats->clear();
 
     // Parse our xml profile
     QString exportFile = QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("export/profiles.xml"));
     parseFile(exportFile, false);
 
     // Parse some MLT's profiles
     parseMltPresets();
 
     QString exportFolder = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/export/");
     QDir directory(exportFolder);
     QStringList filter;
     filter << QStringLiteral("*.xml");
     QStringList fileList = directory.entryList(filter, QDir::Files);
     // We should parse customprofiles.xml in last position, so that user profiles
     // can also override profiles installed by KNewStuff
     fileList.removeAll(QStringLiteral("customprofiles.xml"));
     for (const QString &filename : fileList) {
         parseFile(directory.absoluteFilePath(filename), true);
     }
     if (QFile::exists(exportFolder + QStringLiteral("customprofiles.xml"))) {
         parseFile(exportFolder + QStringLiteral("customprofiles.xml"), true);
     }
 
     focusFirstVisibleItem(selectedProfile);
 }
 
 void RenderWidget::parseMltPresets()
 {
     QDir root(KdenliveSettings::mltpath());
     if (!root.cd(QStringLiteral("../presets/consumer/avformat"))) {
         // Cannot find MLT's presets directory
         qCWarning(KDENLIVE_LOG) << " / / / WARNING, cannot find MLT's preset folder";
         return;
     }
     if (root.cd(QStringLiteral("lossless"))) {
         QString groupName = i18n("Lossless/HQ");
         QList<QTreeWidgetItem *> foundGroup = m_view.formats->findItems(groupName, Qt::MatchExactly);
         QTreeWidgetItem *groupItem;
         if (!foundGroup.isEmpty()) {
             groupItem = foundGroup.takeFirst();
         } else {
             groupItem = new QTreeWidgetItem(QStringList(groupName));
             m_view.formats->addTopLevelItem(groupItem);
             groupItem->setExpanded(true);
         }
 
         const QStringList profiles = root.entryList(QDir::Files, QDir::Name);
         for (const QString &prof : profiles) {
             KConfig config(root.absoluteFilePath(prof), KConfig::SimpleConfig);
             KConfigGroup group = config.group(QByteArray());
             QString vcodec = group.readEntry("vcodec");
             QString acodec = group.readEntry("acodec");
             QString extension = group.readEntry("meta.preset.extension");
             QString note = group.readEntry("meta.preset.note");
             QString profileName = prof;
             if (!vcodec.isEmpty() || !acodec.isEmpty()) {
                 profileName.append(" (");
                 if (!vcodec.isEmpty()) {
                     profileName.append(vcodec);
                     if (!acodec.isEmpty()) {
                         profileName.append("+" + acodec);
                     }
                 } else if (!acodec.isEmpty()) {
                     profileName.append(acodec);
                 }
                 profileName.append(QLatin1Char(')'));
             }
             QTreeWidgetItem *item = new QTreeWidgetItem(QStringList(profileName));
             item->setData(0, ExtensionRole, extension);
             item->setData(0, RenderRole, "avformat");
             item->setData(0, ParamsRole, QString("properties=lossless/" + prof));
             if (!note.isEmpty()) {
                 item->setToolTip(0, note);
             }
             groupItem->addChild(item);
         }
     }
     if (root.cd(QStringLiteral("../stills"))) {
         QString groupName = i18nc("Category Name", "Images sequence");
         QList<QTreeWidgetItem *> foundGroup = m_view.formats->findItems(groupName, Qt::MatchExactly);
         QTreeWidgetItem *groupItem;
         if (!foundGroup.isEmpty()) {
             groupItem = foundGroup.takeFirst();
         } else {
             groupItem = new QTreeWidgetItem(QStringList(groupName));
             m_view.formats->addTopLevelItem(groupItem);
             groupItem->setExpanded(true);
         }
         QStringList profiles = root.entryList(QDir::Files, QDir::Name);
         for (const QString &prof : profiles) {
             QTreeWidgetItem *item = loadFromMltPreset(groupName, root.absoluteFilePath(prof), prof);
             if (!item) {
                 continue;
             }
             item->setData(0, ParamsRole, QString("properties=stills/" + prof));
             groupItem->addChild(item);
         }
         // Add GIF as image sequence
         root.cdUp();
         QTreeWidgetItem *item = loadFromMltPreset(groupName, root.absoluteFilePath(QStringLiteral("GIF")), QStringLiteral("GIF"));
         if (item) {
             item->setData(0, ParamsRole, QStringLiteral("properties=GIF"));
             groupItem->addChild(item);
         }
     }
 }
 
 QTreeWidgetItem *RenderWidget::loadFromMltPreset(const QString &groupName, const QString &path, const QString &profileName)
 {
     KConfig config(path, KConfig::SimpleConfig);
     KConfigGroup group = config.group(QByteArray());
     QString extension = group.readEntry("meta.preset.extension");
     QString note = group.readEntry("meta.preset.note");
     if (extension.isEmpty()) {
         return nullptr;
     }
     QTreeWidgetItem *item = new QTreeWidgetItem(QStringList(profileName));
     item->setData(0, GroupRole, groupName);
     item->setData(0, ExtensionRole, extension);
     item->setData(0, RenderRole, "avformat");
     if (!note.isEmpty()) {
         item->setToolTip(0, note);
     }
     return item;
 }
 
 void RenderWidget::parseFile(const QString &exportFile, bool editable)
 {
     QDomDocument doc;
     QFile file(exportFile);
     doc.setContent(&file, false);
     file.close();
     QDomElement documentElement;
     QDomElement profileElement;
     QString extension;
     QDomNodeList groups = doc.elementsByTagName(QStringLiteral("group"));
     QTreeWidgetItem *item = nullptr;
     bool replaceVorbisCodec = false;
     if (acodecsList.contains(QStringLiteral("libvorbis"))) {
         replaceVorbisCodec = true;
     }
     bool replaceLibfaacCodec = false;
     if (acodecsList.contains(QStringLiteral("libfaac"))) {
         replaceLibfaacCodec = true;
     }
 
     if (editable || groups.isEmpty()) {
         QDomElement profiles = doc.documentElement();
         if (editable && profiles.attribute(QStringLiteral("version"), nullptr).toInt() < 1) {
             // this is an old profile version, update it
             QDomDocument newdoc;
             QDomElement newprofiles = newdoc.createElement(QStringLiteral("profiles"));
             newprofiles.setAttribute(QStringLiteral("version"), 1);
             newdoc.appendChild(newprofiles);
             QDomNodeList profilelist = doc.elementsByTagName(QStringLiteral("profile"));
             for (int i = 0; i < profilelist.count(); ++i) {
                 QString category = i18nc("Category Name", "Custom");
                 QString ext;
                 QDomNode parent = profilelist.at(i).parentNode();
                 if (!parent.isNull()) {
                     QDomElement parentNode = parent.toElement();
                     if (parentNode.hasAttribute(QStringLiteral("name"))) {
                         category = parentNode.attribute(QStringLiteral("name"));
                     }
                     ext = parentNode.attribute(QStringLiteral("extension"));
                 }
                 if (!profilelist.at(i).toElement().hasAttribute(QStringLiteral("category"))) {
                     profilelist.at(i).toElement().setAttribute(QStringLiteral("category"), category);
                 }
                 if (!ext.isEmpty()) {
                     profilelist.at(i).toElement().setAttribute(QStringLiteral("extension"), ext);
                 }
                 QDomNode n = profilelist.at(i).cloneNode();
                 newprofiles.appendChild(newdoc.importNode(n, true));
             }
             if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                 KMessageBox::sorry(this, i18n("Unable to write to file %1", exportFile));
                 return;
             }
             QTextStream out(&file);
             out << newdoc.toString();
             file.close();
             parseFile(exportFile, editable);
             return;
         }
 
         QDomNode node = doc.elementsByTagName(QStringLiteral("profile")).at(0);
         if (node.isNull()) {
             return;
         }
         int count = 1;
         while (!node.isNull()) {
             QDomElement profile = node.toElement();
             QString profileName = profile.attribute(QStringLiteral("name"));
             QString standard = profile.attribute(QStringLiteral("standard"));
             QTextDocument docConvert;
             docConvert.setHtml(profile.attribute(QStringLiteral("args")));
             QString params = docConvert.toPlainText().simplified();
 
             if (replaceVorbisCodec && params.contains(QStringLiteral("acodec=vorbis"))) {
                 // replace vorbis with libvorbis
                 params = params.replace(QLatin1String("=vorbis"), QLatin1String("=libvorbis"));
             }
             if (replaceLibfaacCodec && params.contains(QStringLiteral("acodec=aac"))) {
                 // replace libfaac with aac
                 params = params.replace(QLatin1String("aac"), QLatin1String("libfaac"));
             }
 
             QString prof_extension = profile.attribute(QStringLiteral("extension"));
             if (!prof_extension.isEmpty()) {
                 extension = prof_extension;
             }
             QString groupName = profile.attribute(QStringLiteral("category"), i18nc("Category Name", "Custom"));
             QList<QTreeWidgetItem *> foundGroup = m_view.formats->findItems(groupName, Qt::MatchExactly);
             QTreeWidgetItem *groupItem;
             if (!foundGroup.isEmpty()) {
                 groupItem = foundGroup.takeFirst();
             } else {
                 groupItem = new QTreeWidgetItem(QStringList(groupName));
                 if (editable) {
                     m_view.formats->insertTopLevelItem(0, groupItem);
                 } else {
                     m_view.formats->addTopLevelItem(groupItem);
                     groupItem->setExpanded(true);
                 }
             }
 
             // Check if item with same name already exists and replace it,
             // allowing to override default profiles
             QTreeWidgetItem *childitem = nullptr;
             for (int j = 0; j < groupItem->childCount(); ++j) {
                 if (groupItem->child(j)->text(0) == profileName) {
                     childitem = groupItem->child(j);
                     break;
                 }
             }
             if (!childitem) {
                 childitem = new QTreeWidgetItem(QStringList(profileName));
             }
             childitem->setData(0, GroupRole, groupName);
             childitem->setData(0, ExtensionRole, extension);
             childitem->setData(0, RenderRole, "avformat");
             childitem->setData(0, StandardRole, standard);
             childitem->setData(0, ParamsRole, params);
             if (params.contains(QLatin1String("%quality"))) {
                 childitem->setData(0, BitratesRole, profile.attribute(QStringLiteral("qualities")).split(QLatin1Char(','), QString::SkipEmptyParts));
             } else if (params.contains(QLatin1String("%bitrate"))) {
                 childitem->setData(0, BitratesRole, profile.attribute(QStringLiteral("bitrates")).split(QLatin1Char(','), QString::SkipEmptyParts));
             }
             if (params.contains(QLatin1String("%audioquality"))) {
                 childitem->setData(0, AudioBitratesRole, profile.attribute(QStringLiteral("audioqualities")).split(QLatin1Char(','), QString::SkipEmptyParts));
             } else if (params.contains(QLatin1String("%audiobitrate"))) {
                 childitem->setData(0, AudioBitratesRole, profile.attribute(QStringLiteral("audiobitrates")).split(QLatin1Char(','), QString::SkipEmptyParts));
             }
             if (profile.hasAttribute(QStringLiteral("speeds"))) {
                 childitem->setData(0, SpeedsRole, profile.attribute(QStringLiteral("speeds")).split(QLatin1Char(';'), QString::SkipEmptyParts));
             }
             if (profile.hasAttribute(QStringLiteral("url"))) {
                 childitem->setData(0, ExtraRole, profile.attribute(QStringLiteral("url")));
             }
             if (profile.hasAttribute(QStringLiteral("top_field_first"))) {
                 childitem->setData(0, FieldRole, profile.attribute(QStringLiteral("top_field_first")));
             }
             if (editable) {
                 childitem->setData(0, EditableRole, exportFile);
                 if (exportFile.endsWith(QLatin1String("customprofiles.xml"))) {
                     childitem->setIcon(0, QIcon::fromTheme(QStringLiteral("favorite")));
                 } else {
                     childitem->setIcon(0, QIcon::fromTheme(QStringLiteral("internet-services")));
                 }
             }
             groupItem->addChild(childitem);
             node = doc.elementsByTagName(QStringLiteral("profile")).at(count);
             count++;
         }
         return;
     }
 
     int i = 0;
     QString groupName;
     QString profileName;
 
     QString prof_extension;
     QString renderer;
     QString params;
     QString standard;
 
     while (!groups.item(i).isNull()) {
         documentElement = groups.item(i).toElement();
         QDomNode gname = documentElement.elementsByTagName(QStringLiteral("groupname")).at(0);
         groupName = documentElement.attribute(QStringLiteral("name"), i18nc("Attribute Name", "Custom"));
         extension = documentElement.attribute(QStringLiteral("extension"), QString());
         renderer = documentElement.attribute(QStringLiteral("renderer"), QString());
         QList<QTreeWidgetItem *> foundGroup = m_view.formats->findItems(groupName, Qt::MatchExactly);
         QTreeWidgetItem *groupItem;
         if (!foundGroup.isEmpty()) {
             groupItem = foundGroup.takeFirst();
         } else {
             groupItem = new QTreeWidgetItem(QStringList(groupName));
             m_view.formats->addTopLevelItem(groupItem);
             groupItem->setExpanded(true);
         }
 
         QDomNode n = groups.item(i).firstChild();
         while (!n.isNull()) {
             if (n.toElement().tagName() != QLatin1String("profile")) {
                 n = n.nextSibling();
                 continue;
             }
             profileElement = n.toElement();
             profileName = profileElement.attribute(QStringLiteral("name"));
             standard = profileElement.attribute(QStringLiteral("standard"));
             params = profileElement.attribute(QStringLiteral("args")).simplified();
 
             if (replaceVorbisCodec && params.contains(QStringLiteral("acodec=vorbis"))) {
                 // replace vorbis with libvorbis
                 params = params.replace(QLatin1String("=vorbis"), QLatin1String("=libvorbis"));
             }
             if (replaceLibfaacCodec && params.contains(QStringLiteral("acodec=aac"))) {
                 // replace libfaac with aac
                 params = params.replace(QLatin1String("aac"), QLatin1String("libfaac"));
             }
 
             prof_extension = profileElement.attribute(QStringLiteral("extension"));
             if (!prof_extension.isEmpty()) {
                 extension = prof_extension;
             }
             item = new QTreeWidgetItem(QStringList(profileName));
             item->setData(0, GroupRole, groupName);
             item->setData(0, ExtensionRole, extension);
             item->setData(0, RenderRole, renderer);
             item->setData(0, StandardRole, standard);
             item->setData(0, ParamsRole, params);
             if (params.contains(QLatin1String("%quality"))) {
                 item->setData(0, BitratesRole, profileElement.attribute(QStringLiteral("qualities")).split(QLatin1Char(','), QString::SkipEmptyParts));
             } else if (params.contains(QLatin1String("%bitrate"))) {
                 item->setData(0, BitratesRole, profileElement.attribute(QStringLiteral("bitrates")).split(QLatin1Char(','), QString::SkipEmptyParts));
             }
             if (params.contains(QLatin1String("%audioquality"))) {
                 item->setData(0, AudioBitratesRole,
                               profileElement.attribute(QStringLiteral("audioqualities")).split(QLatin1Char(','), QString::SkipEmptyParts));
             } else if (params.contains(QLatin1String("%audiobitrate"))) {
                 item->setData(0, AudioBitratesRole, profileElement.attribute(QStringLiteral("audiobitrates")).split(QLatin1Char(','), QString::SkipEmptyParts));
             }
             if (profileElement.hasAttribute(QStringLiteral("speeds"))) {
                 item->setData(0, SpeedsRole, profileElement.attribute(QStringLiteral("speeds")).split(QLatin1Char(';'), QString::SkipEmptyParts));
             }
             if (profileElement.hasAttribute(QStringLiteral("url"))) {
                 item->setData(0, ExtraRole, profileElement.attribute(QStringLiteral("url")));
             }
             groupItem->addChild(item);
             n = n.nextSibling();
         }
 
         ++i;
     }
 }
 
 void RenderWidget::setRenderJob(const QString &dest, int progress)
 {
     RenderJobItem *item;
     QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
     if (!existing.isEmpty()) {
         item = static_cast<RenderJobItem *>(existing.at(0));
     } else {
         item = new RenderJobItem(m_view.running_jobs, QStringList() << QString() << dest);
         if (progress == 0) {
             item->setStatus(WAITINGJOB);
         }
     }
     item->setData(1, ProgressRole, progress);
     item->setStatus(RUNNINGJOB);
     if (progress == 0) {
         item->setIcon(0, QIcon::fromTheme(QStringLiteral("media-record")));
         item->setData(1, TimeRole, QDateTime::currentDateTime());
         slotCheckJob();
     } else {
         QDateTime startTime = item->data(1, TimeRole).toDateTime();
         qint64 elapsedTime = startTime.secsTo(QDateTime::currentDateTime());
         qint64 remaining = elapsedTime * (100 - progress) / progress;
         int days = static_cast<int>(remaining / 86400);
         int remainingSecs = static_cast<int>(remaining % 86400);
         QTime when = QTime(0, 0, 0, 0);
         when = when.addSecs(remainingSecs);
         QString est = (days > 0) ? i18np("%1 day ", "%1 days ", days) : QString();
         est.append(when.toString(QStringLiteral("hh:mm:ss")));
         QString t = i18n("Remaining time %1", est);
         item->setData(1, Qt::UserRole, t);
     }
 }
 
 void RenderWidget::setRenderStatus(const QString &dest, int status, const QString &error)
 {
     RenderJobItem *item;
     QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
     if (!existing.isEmpty()) {
         item = static_cast<RenderJobItem *>(existing.at(0));
     } else {
         item = new RenderJobItem(m_view.running_jobs, QStringList() << QString() << dest);
     }
     if (!item) {
         return;
     }
     if (status == -1) {
         // Job finished successfully
         item->setStatus(FINISHEDJOB);
         QDateTime startTime = item->data(1, TimeRole).toDateTime();
         qint64 elapsedTime = startTime.secsTo(QDateTime::currentDateTime());
         int days = static_cast<int>(elapsedTime / 86400);
         int secs = static_cast<int>(elapsedTime % 86400);
         QTime when = QTime(0, 0, 0, 0);
         when = when.addSecs(secs);
         QString est = (days > 0) ? i18np("%1 day ", "%1 days ", days) : QString();
         est.append(when.toString(QStringLiteral("hh:mm:ss")));
         QString t = i18n("Rendering finished in %1", est);
         item->setData(1, Qt::UserRole, t);
 
 #ifdef KF5_USE_PURPOSE
         m_shareMenu->model()->setInputData(QJsonObject{{QStringLiteral("mimeType"), QMimeDatabase().mimeTypeForFile(item->text(1)).name()},
                                                        {QStringLiteral("urls"), QJsonArray({item->text(1)})}});
         m_shareMenu->model()->setPluginType(QStringLiteral("Export"));
         m_shareMenu->reload();
 #endif
         QString notif = i18n("Rendering of %1 finished in %2", item->text(1), est);
         KNotification *notify = new KNotification(QStringLiteral("RenderFinished"));
         notify->setText(notif);
         notify->setUrls({QUrl::fromLocalFile(dest)});
         notify->sendEvent();
         QString itemGroup = item->data(0, Qt::UserRole).toString();
         if (itemGroup == QLatin1String("dvd")) {
             emit openDvdWizard(item->text(1));
         } else if (itemGroup == QLatin1String("websites")) {
             QString url = item->metadata();
             if (!url.isEmpty()) {
                 new KRun(QUrl::fromLocalFile(url), this);
             }
         }
     } else if (status == -2) {
         // Rendering crashed
         item->setStatus(FAILEDJOB);
         m_view.error_log->append(i18n("<strong>Rendering of %1 crashed</strong><br />", dest));
         m_view.error_log->append(error);
         m_view.error_log->append(QStringLiteral("<hr />"));
         m_view.error_box->setVisible(true);
     } else if (status == -3) {
         // User aborted job
         item->setStatus(ABORTEDJOB);
     } else {
         delete item;
     }
     slotCheckJob();
     checkRenderStatus();
 }
 
 void RenderWidget::slotAbortCurrentJob()
 {
     auto *current = static_cast<RenderJobItem *>(m_view.running_jobs->currentItem());
     if (current) {
         if (current->status() == RUNNINGJOB) {
             emit abortProcess(current->text(1));
         } else {
             delete current;
             slotCheckJob();
             checkRenderStatus();
         }
     }
 }
 
 void RenderWidget::slotStartCurrentJob()
 {
     auto *current = static_cast<RenderJobItem *>(m_view.running_jobs->currentItem());
     if ((current != nullptr) && current->status() == WAITINGJOB) {
         startRendering(current);
     }
     m_view.start_job->setEnabled(false);
 }
 
 void RenderWidget::slotCheckJob()
 {
     bool activate = false;
     auto *current = static_cast<RenderJobItem *>(m_view.running_jobs->currentItem());
     if (current) {
         if (current->status() == RUNNINGJOB || current->status() == STARTINGJOB) {
             m_view.abort_job->setText(i18n("Abort Job"));
             m_view.start_job->setEnabled(false);
         } else {
             m_view.abort_job->setText(i18n("Remove Job"));
             m_view.start_job->setEnabled(current->status() == WAITINGJOB);
         }
         activate = true;
 #ifdef KF5_USE_PURPOSE
         if (current->status() == FINISHEDJOB) {
             m_shareMenu->model()->setInputData(QJsonObject{{QStringLiteral("mimeType"), QMimeDatabase().mimeTypeForFile(current->text(1)).name()},
                                                            {QStringLiteral("urls"), QJsonArray({current->text(1)})}});
             m_shareMenu->model()->setPluginType(QStringLiteral("Export"));
             m_shareMenu->reload();
             m_view.shareButton->setEnabled(true);
         } else {
             m_view.shareButton->setEnabled(false);
         }
 #endif
     }
     m_view.abort_job->setEnabled(activate);
     /*
     for (int i = 0; i < m_view.running_jobs->topLevelItemCount(); ++i) {
         current = static_cast<RenderJobItem*>(m_view.running_jobs->topLevelItem(i));
         if (current == static_cast<RenderJobItem*> (m_view.running_jobs->currentItem())) {
             current->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 3));
         } else current->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
     }*/
 }
 
 void RenderWidget::slotCLeanUpJobs()
 {
     int ix = 0;
     auto *current = static_cast<RenderJobItem *>(m_view.running_jobs->topLevelItem(ix));
     while (current != nullptr) {
         if (current->status() == FINISHEDJOB || current->status() == ABORTEDJOB) {
             delete current;
         } else {
             ix++;
         }
         current = static_cast<RenderJobItem *>(m_view.running_jobs->topLevelItem(ix));
     }
     slotCheckJob();
 }
 
 void RenderWidget::parseScriptFiles()
 {
     QStringList scriptsFilter;
     scriptsFilter << QStringLiteral("*.mlt");
     m_view.scripts_list->clear();
 
     QTreeWidgetItem *item;
     // List the project scripts
     QDir projectFolder(pCore->currentDoc()->projectDataFolder());
     projectFolder.mkpath(QStringLiteral("kdenlive-renderqueue"));
     projectFolder.cd(QStringLiteral("kdenlive-renderqueue"));
     QStringList scriptFiles = projectFolder.entryList(scriptsFilter, QDir::Files);
     for (int i = 0; i < scriptFiles.size(); ++i) {
         QUrl scriptpath = QUrl::fromLocalFile(projectFolder.absoluteFilePath(scriptFiles.at(i)));
         QFile f(scriptpath.toLocalFile());
         QDomDocument doc;
         doc.setContent(&f, false);
         f.close();
         QDomElement consumer = doc.documentElement().firstChildElement(QStringLiteral("consumer"));
         if (consumer.isNull()) {
             continue;
         }
         QString target = consumer.attribute(QStringLiteral("target"));
         if (target.isEmpty()) {
             continue;
         }
         item = new QTreeWidgetItem(m_view.scripts_list, QStringList() << QString() << scriptpath.fileName());
         auto icon = QFileIconProvider().icon(QFileInfo(f));
         item->setIcon(0, icon.isNull() ? QIcon::fromTheme(QStringLiteral("application-x-executable-script")) : icon);
         item->setSizeHint(0, QSize(m_view.scripts_list->columnWidth(0), fontMetrics().height() * 2));
         item->setData(1, Qt::UserRole, QUrl(QUrl::fromEncoded(target.toUtf8())).url(QUrl::PreferLocalFile));
         item->setData(1, Qt::UserRole + 1, scriptpath.toLocalFile());
     }
     QTreeWidgetItem *script = m_view.scripts_list->topLevelItem(0);
     if (script) {
         m_view.scripts_list->setCurrentItem(script);
         script->setSelected(true);
     }
 }
 
 void RenderWidget::slotCheckScript()
 {
     QTreeWidgetItem *current = m_view.scripts_list->currentItem();
     if (current == nullptr) {
         return;
     }
     m_view.start_script->setEnabled(current->data(0, Qt::UserRole).toString().isEmpty());
     m_view.delete_script->setEnabled(true);
     for (int i = 0; i < m_view.scripts_list->topLevelItemCount(); ++i) {
         current = m_view.scripts_list->topLevelItem(i);
         if (current == m_view.scripts_list->currentItem()) {
             current->setSizeHint(1, QSize(m_view.scripts_list->columnWidth(1), fontMetrics().height() * 3));
         } else {
             current->setSizeHint(1, QSize(m_view.scripts_list->columnWidth(1), fontMetrics().height() * 2));
         }
     }
 }
 
 void RenderWidget::slotStartScript()
 {
     auto *item = static_cast<RenderJobItem *>(m_view.scripts_list->currentItem());
     if (item) {
         QString destination = item->data(1, Qt::UserRole).toString();
         if (QFile::exists(destination)) {
             if (KMessageBox::warningYesNo(this, i18n("Output file already exists. Do you want to overwrite it?")) != KMessageBox::Yes) {
                 return;
             }
         }
         QString path = item->data(1, Qt::UserRole + 1).toString();
         // Insert new job in queue
         RenderJobItem *renderItem = nullptr;
         QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(destination, Qt::MatchExactly, 1);
         if (!existing.isEmpty()) {
             renderItem = static_cast<RenderJobItem *>(existing.at(0));
             if (renderItem->status() == RUNNINGJOB || renderItem->status() == WAITINGJOB || renderItem->status() == STARTINGJOB) {
                 KMessageBox::information(
                     this, i18n("There is already a job writing file:<br /><b>%1</b><br />Abort the job if you want to overwrite it...", destination),
                     i18n("Already running"));
                 return;
             }
             delete renderItem;
             renderItem = nullptr;
         }
         if (!renderItem) {
             renderItem = new RenderJobItem(m_view.running_jobs, QStringList() << QString() << destination);
         }
         renderItem->setData(1, ProgressRole, 0);
         renderItem->setStatus(WAITINGJOB);
         renderItem->setIcon(0, QIcon::fromTheme(QStringLiteral("media-playback-pause")));
         renderItem->setData(1, Qt::UserRole, i18n("Waiting..."));
         renderItem->setData(1, TimeRole, QDateTime::currentDateTime());
         QStringList argsJob = {KdenliveSettings::rendererpath(), path, destination, QStringLiteral("-pid:%1").arg(QCoreApplication::applicationPid())};
         renderItem->setData(1, ParametersRole, argsJob);
         checkRenderStatus();
         m_view.tabWidget->setCurrentIndex(1);
     }
 }
 
 void RenderWidget::slotDeleteScript()
 {
     QTreeWidgetItem *item = m_view.scripts_list->currentItem();
     if (item) {
         QString path = item->data(1, Qt::UserRole + 1).toString();
         bool success = true;
         success &= static_cast<int>(QFile::remove(path));
         if (!success) {
             qCWarning(KDENLIVE_LOG) << "// Error removing script or playlist: " << path << ", " << path << ".mlt";
         }
         parseScriptFiles();
     }
 }
 
 void RenderWidget::slotGenerateScript()
 {
     slotPrepareExport(true);
 }
 
 void RenderWidget::slotHideLog()
 {
     m_view.error_box->setVisible(false);
 }
 
 void RenderWidget::setRenderProfile(const QMap<QString, QString> &props)
 {
     m_view.scanning_list->setCurrentIndex(props.value(QStringLiteral("renderscanning")).toInt());
     m_view.field_order->setCurrentIndex(props.value(QStringLiteral("renderfield")).toInt());
     int exportAudio = props.value(QStringLiteral("renderexportaudio")).toInt();
     switch (exportAudio) {
     case 1:
         m_view.export_audio->setCheckState(Qt::Unchecked);
         break;
     case 2:
         m_view.export_audio->setCheckState(Qt::Checked);
         break;
     default:
         m_view.export_audio->setCheckState(Qt::PartiallyChecked);
     }
     if (props.contains(QStringLiteral("renderrescale"))) {
         m_view.rescale->setChecked(props.value(QStringLiteral("renderrescale")).toInt() != 0);
     }
     if (props.contains(QStringLiteral("renderrescalewidth"))) {
         m_view.rescale_width->setValue(props.value(QStringLiteral("renderrescalewidth")).toInt());
     } else {
         std::unique_ptr<ProfileModel> &profile = pCore->getCurrentProfile();
         m_view.rescale_width->setValue(profile->width() / 2);
         slotUpdateRescaleWidth(m_view.rescale_width->value());
     }
     if (props.contains(QStringLiteral("renderrescaleheight"))) {
         m_view.rescale_height->setValue(props.value(QStringLiteral("renderrescaleheight")).toInt());
     }
     if (props.contains(QStringLiteral("rendertcoverlay"))) {
         m_view.tc_overlay->setChecked(props.value(QStringLiteral("rendertcoverlay")).toInt() != 0);
     }
     if (props.contains(QStringLiteral("rendertctype"))) {
         m_view.tc_type->setCurrentIndex(props.value(QStringLiteral("rendertctype")).toInt());
     }
     if (props.contains(QStringLiteral("renderratio"))) {
         m_view.rescale_keep->setChecked(props.value(QStringLiteral("renderratio")).toInt() != 0);
     }
     if (props.contains(QStringLiteral("renderplay"))) {
         m_view.play_after->setChecked(props.value(QStringLiteral("renderplay")).toInt() != 0);
     }
     if (props.contains(QStringLiteral("rendertwopass"))) {
         m_view.checkTwoPass->setChecked(props.value(QStringLiteral("rendertwopass")).toInt() != 0);
     }
 
     if (props.value(QStringLiteral("renderzone")) == QLatin1String("1")) {
         m_view.render_zone->setChecked(true);
     } else if (props.value(QStringLiteral("renderguide")) == QLatin1String("1")) {
         m_view.render_guide->setChecked(true);
         m_view.guide_start->setCurrentIndex(props.value(QStringLiteral("renderstartguide")).toInt());
         m_view.guide_end->setCurrentIndex(props.value(QStringLiteral("renderendguide")).toInt());
     } else {
         m_view.render_full->setChecked(true);
     }
     slotUpdateGuideBox();
 
     QString url = props.value(QStringLiteral("renderurl"));
     if (url.isEmpty()) {
         QTreeWidgetItem *item = m_view.formats->currentItem();
         if (item && item->parent()) { // categories have no parent
             const QString extension = item->data(0, ExtensionRole).toString();
             url = filenameWithExtension(QUrl::fromLocalFile(pCore->currentDoc()->projectDataFolder() + QDir::separator()), extension).toLocalFile();
         }
     } else if (QFileInfo(url).isRelative()) {
         url.prepend(pCore->currentDoc()->documentRoot());
     }
     m_view.out_file->setUrl(QUrl::fromLocalFile(url));
 
     if (props.contains(QStringLiteral("renderprofile")) || props.contains(QStringLiteral("rendercategory"))) {
         focusFirstVisibleItem(props.value(QStringLiteral("renderprofile")));
     }
 
     if (props.contains(QStringLiteral("renderquality"))) {
         m_view.video->setValue(props.value(QStringLiteral("renderquality")).toInt());
     } else if (props.contains(QStringLiteral("renderbitrate"))) {
         m_view.video->setValue(props.value(QStringLiteral("renderbitrate")).toInt());
     } else {
         m_view.quality->setValue(m_view.quality->maximum() * 3 / 4);
     }
     if (props.contains(QStringLiteral("renderaudioquality"))) {
         m_view.audio->setValue(props.value(QStringLiteral("renderaudioquality")).toInt());
     }
     if (props.contains(QStringLiteral("renderaudiobitrate"))) {
         m_view.audio->setValue(props.value(QStringLiteral("renderaudiobitrate")).toInt());
     }
 
     if (props.contains(QStringLiteral("renderspeed"))) {
         m_view.speed->setValue(props.value(QStringLiteral("renderspeed")).toInt());
     }
 }
 
 bool RenderWidget::startWaitingRenderJobs()
 {
     m_blockProcessing = true;
 #ifdef Q_OS_WIN
     const QLatin1String ScriptFormat(".bat");
 #else
     const QLatin1String ScriptFormat(".sh");
 #endif
     QTemporaryFile tmp(QDir::tempPath() + QStringLiteral("/kdenlive-XXXXXX") + ScriptFormat);
     if (!tmp.open()) {
         // Something went wrong
         return false;
     }
     tmp.close();
     QString autoscriptFile = tmp.fileName();
     QFile file(autoscriptFile);
     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         qCWarning(KDENLIVE_LOG) << "//////  ERROR writing to file: " << autoscriptFile;
         KMessageBox::error(nullptr, i18n("Cannot write to file %1", autoscriptFile));
         return false;
     }
 
     QTextStream outStream(&file);
 #ifndef Q_OS_WIN
     outStream << "#! /bin/sh" << '\n' << '\n';
 #endif
     auto *item = static_cast<RenderJobItem *>(m_view.running_jobs->topLevelItem(0));
     while (item != nullptr) {
         if (item->status() == WAITINGJOB) {
             // Add render process for item
             const QString params = item->data(1, ParametersRole).toStringList().join(QLatin1Char(' '));
             outStream << '\"' << m_renderer << "\" " << params << '\n';
         }
         item = static_cast<RenderJobItem *>(m_view.running_jobs->itemBelow(item));
     }
 // erase itself when rendering is finished
 #ifndef Q_OS_WIN
     outStream << "rm \"" << autoscriptFile << "\"\n";
 #else
     outStream << "del \"" << autoscriptFile << "\"\n";
 #endif
     if (file.error() != QFile::NoError) {
         KMessageBox::error(nullptr, i18n("Cannot write to file %1", autoscriptFile));
         file.close();
         m_blockProcessing = false;
         return false;
     }
     file.close();
     QFile::setPermissions(autoscriptFile, file.permissions() | QFile::ExeUser);
     QProcess::startDetached(autoscriptFile, QStringList());
     return true;
 }
 
 void RenderWidget::slotPlayRendering(QTreeWidgetItem *item, int)
 {
     auto *renderItem = static_cast<RenderJobItem *>(item);
     if (renderItem->status() != FINISHEDJOB) {
         return;
     }
     new KRun(QUrl::fromLocalFile(item->text(1)), this);
 }
 
 void RenderWidget::errorMessage(RenderError type, const QString &message)
 {
     QString fullMessage;
     m_errorMessages.insert(type, message);
     QMapIterator<int, QString> i(m_errorMessages);
     while (i.hasNext()) {
         i.next();
         if (!i.value().isEmpty()) {
             if (!fullMessage.isEmpty()) {
                 fullMessage.append(QLatin1Char('\n'));
             }
             fullMessage.append(i.value());
         }
     }
     if (!fullMessage.isEmpty()) {
         m_infoMessage->setMessageType(KMessageWidget::Warning);
         m_infoMessage->setText(fullMessage);
         m_infoMessage->show();
     } else {
         m_infoMessage->hide();
     }
 }
 
 void RenderWidget::slotUpdateEncodeThreads(int val)
 {
     KdenliveSettings::setEncodethreads(val);
 }
 
 void RenderWidget::slotUpdateRescaleWidth(int val)
 {
     KdenliveSettings::setDefaultrescalewidth(val);
     if (!m_view.rescale_keep->isChecked()) {
         return;
     }
     m_view.rescale_height->blockSignals(true);
     std::unique_ptr<ProfileModel> &profile = pCore->getCurrentProfile();
     m_view.rescale_height->setValue(val * profile->height() / profile->width());
     KdenliveSettings::setDefaultrescaleheight(m_view.rescale_height->value());
     m_view.rescale_height->blockSignals(false);
 }
 
 void RenderWidget::slotUpdateRescaleHeight(int val)
 {
     KdenliveSettings::setDefaultrescaleheight(val);
     if (!m_view.rescale_keep->isChecked()) {
         return;
     }
     m_view.rescale_width->blockSignals(true);
     std::unique_ptr<ProfileModel> &profile = pCore->getCurrentProfile();
     m_view.rescale_width->setValue(val * profile->width() / profile->height());
     KdenliveSettings::setDefaultrescaleheight(m_view.rescale_width->value());
     m_view.rescale_width->blockSignals(false);
 }
 
 void RenderWidget::slotSwitchAspectRatio()
 {
     KdenliveSettings::setRescalekeepratio(m_view.rescale_keep->isChecked());
     if (m_view.rescale_keep->isChecked()) {
         slotUpdateRescaleWidth(m_view.rescale_width->value());
     }
 }
 
 void RenderWidget::slotUpdateAudioLabel(int ix)
 {
     if (ix == Qt::PartiallyChecked) {
         m_view.export_audio->setText(i18n("Export audio (automatic)"));
     } else {
         m_view.export_audio->setText(i18n("Export audio"));
     }
     m_view.stemAudioExport->setEnabled(ix != Qt::Unchecked);
 }
 
 bool RenderWidget::automaticAudioExport() const
 {
     return (m_view.export_audio->checkState() == Qt::PartiallyChecked);
 }
 
 bool RenderWidget::selectedAudioExport() const
 {
     return (m_view.export_audio->checkState() != Qt::Unchecked);
 }
 
 void RenderWidget::updateProxyConfig(bool enable)
 {
     m_view.proxy_render->setHidden(!enable);
 }
 
 bool RenderWidget::proxyRendering()
 {
     return m_view.proxy_render->isChecked();
 }
 
 bool RenderWidget::isStemAudioExportEnabled() const
 {
     return (m_view.stemAudioExport->isChecked() && m_view.stemAudioExport->isVisible() && m_view.stemAudioExport->isEnabled());
 }
 
 void RenderWidget::setRescaleEnabled(bool enable)
 {
     for (int i = 0; i < m_view.rescale_box->layout()->count(); ++i) {
         if (m_view.rescale_box->itemAt(i)->widget()) {
             m_view.rescale_box->itemAt(i)->widget()->setEnabled(enable);
         }
     }
 }
 
 void RenderWidget::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter) {
         switch (m_view.tabWidget->currentIndex()) {
         case 1:
             if (m_view.start_job->isEnabled()) {
                 slotStartCurrentJob();
             }
             break;
         case 2:
             if (m_view.start_script->isEnabled()) {
                 slotStartScript();
             }
             break;
         default:
             if (m_view.buttonRender->isEnabled()) {
                 slotPrepareExport();
             }
             break;
         }
     } else if (e->key() == Qt::Key_Delete) {
         // If in Scripts tab, let Del key invoke DeleteScript
         if (m_view.tabWidget->currentIndex() == 2) {
             if (m_view.delete_script->isEnabled()) {
                 slotDeleteScript();
             }
         } else {
             QDialog::keyPressEvent(e);
         }
     } else {
         QDialog::keyPressEvent(e);
     }
 }
 
 void RenderWidget::adjustAVQualities(int quality)
 {
     // calculate video/audio quality indexes from the general quality cursor
     // taking into account decreasing/increasing video/audio quality parameter
     double q = double(quality) / m_view.quality->maximum();
 
     int dq = int(q * (m_view.video->maximum() - m_view.video->minimum()));
     // prevent video spinbox to update quality cursor (loop)
     m_view.video->blockSignals(true);
     m_view.video->setValue(m_view.video->property("decreasing").toBool() ? m_view.video->maximum() - dq : m_view.video->minimum() + dq);
     m_view.video->blockSignals(false);
     dq = int(q * (m_view.audio->maximum() - m_view.audio->minimum()));
     dq -= dq % m_view.audio->singleStep(); // keep a 32 pitch  for bitrates
     m_view.audio->setValue(m_view.audio->property("decreasing").toBool() ? m_view.audio->maximum() - dq : m_view.audio->minimum() + dq);
 }
 
 void RenderWidget::adjustQuality(int videoQuality)
 {
     int dq = videoQuality * m_view.quality->maximum() / (m_view.video->maximum() - m_view.video->minimum());
     m_view.quality->blockSignals(true);
     m_view.quality->setValue(m_view.video->property("decreasing").toBool() ? m_view.video->maximum() - dq : m_view.video->minimum() + dq);
     m_view.quality->blockSignals(false);
 }
 
 void RenderWidget::adjustSpeed(int speedIndex)
 {
     if (m_view.formats->currentItem()) {
         QStringList speeds = m_view.formats->currentItem()->data(0, SpeedsRole).toStringList();
         if (speedIndex < speeds.count()) {
             m_view.speed->setToolTip(i18n("Codec speed parameters:\n%1", speeds.at(speedIndex)));
         }
     }
 }
 
 void RenderWidget::checkCodecs()
 {
     Mlt::Profile p;
     auto *consumer = new Mlt::Consumer(p, "avformat");
     if (consumer) {
         consumer->set("vcodec", "list");
         consumer->set("acodec", "list");
         consumer->set("f", "list");
         consumer->start();
         vcodecsList.clear();
         Mlt::Properties vcodecs(mlt_properties(consumer->get_data("vcodec")));
         vcodecsList.reserve(vcodecs.count());
         for (int i = 0; i < vcodecs.count(); ++i) {
             vcodecsList << QString(vcodecs.get(i));
         }
         acodecsList.clear();
         Mlt::Properties acodecs(mlt_properties(consumer->get_data("acodec")));
         acodecsList.reserve(acodecs.count());
         for (int i = 0; i < acodecs.count(); ++i) {
             acodecsList << QString(acodecs.get(i));
         }
         supportedFormats.clear();
         Mlt::Properties formats(mlt_properties(consumer->get_data("f")));
         supportedFormats.reserve(formats.count());
         for (int i = 0; i < formats.count(); ++i) {
             supportedFormats << QString(formats.get(i));
         }
         delete consumer;
     }
 }
 
 void RenderWidget::slotProxyWarn(bool enableProxy)
 {
     errorMessage(ProxyWarning, enableProxy ? i18n("Rendering using low quality proxy") : QString());
 }
 
 void RenderWidget::prepareMenu(const QPoint &pos)
 {
     QTreeWidgetItem *nd = m_view.running_jobs->itemAt( pos );
     RenderJobItem *renderItem = nullptr;
     if (nd) {
         renderItem = static_cast<RenderJobItem *>(nd);
     }
     if (!renderItem) {
         return;
     }
     if (renderItem->status() != FINISHEDJOB) {
         return;
     }
     QMenu menu(this);
     QAction *newAct = new QAction(i18n("Add to current project"), this);
     connect(newAct, &QAction::triggered, [&, renderItem]() {
         pCore->bin()->slotAddClipToProject(QUrl::fromLocalFile(renderItem->text(1)));
     });
     menu.addAction(newAct);
     
     menu.exec(m_view.running_jobs->mapToGlobal(pos));
 }
diff --git a/src/dialogs/titletemplatedialog.cpp b/src/dialogs/titletemplatedialog.cpp
index 982227c9d..62ab5b228 100644
--- a/src/dialogs/titletemplatedialog.cpp
+++ b/src/dialogs/titletemplatedialog.cpp
@@ -1,104 +1,100 @@
 /*
 Copyright (C) 2016  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 "titletemplatedialog.h"
 #include "doc/kthumb.h"
 #include "kdenlivesettings.h"
 
 #include "klocalizedstring.h"
 #include <KComboBox>
 #include <QDir>
 #include <QStandardPaths>
 
 TitleTemplateDialog::TitleTemplateDialog(const QString &folder, QWidget *parent)
     : QDialog(parent)
 {
     m_view.setupUi(this);
     // Get the list of existing templates
     const QStringList filter = {QStringLiteral("*.kdenlivetitle")};
     const QString path = folder + QStringLiteral("/titles/");
 
     // Project templates
     QDir dir(path);
     const QStringList templateFiles = dir.entryList(filter, QDir::Files);
     for (const QString &fname : templateFiles) {
         m_view.template_list->comboBox()->addItem(fname, dir.absoluteFilePath(fname));
     }
 
     // System templates
     const QStringList titleTemplates = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, QStringLiteral("titles/"), QStandardPaths::LocateDirectory);
 
     for (const QString &folderpath : titleTemplates) {
         QDir sysdir(folderpath);
         const QStringList filesnames = sysdir.entryList(filter, QDir::Files);
         for (const QString &fname : filesnames) {
             m_view.template_list->comboBox()->addItem(fname, sysdir.absoluteFilePath(fname));
         }
     }
 
     if (m_view.template_list->comboBox()->count() > 0) {
         m_view.buttonBox->button(QDialogButtonBox::Ok)->setFocus();
     }
     int current = m_view.template_list->comboBox()->findText(KdenliveSettings::selected_template());
     if (current > -1) {
         m_view.template_list->comboBox()->setCurrentIndex(current);
     }
     const QStringList mimeTypeFilters = {QStringLiteral("application/x-kdenlivetitle")};
     m_view.template_list->setMimeTypeFilters(mimeTypeFilters);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_view.template_list->comboBox(), static_cast<void (KComboBox::*)(int)>(&KComboBox::currentIndexChanged), this,
-#else
-    connect(m_view.template_list->comboBox(), static_cast<void (KComboBox::*)(int, const QString &)>(&KComboBox::currentIndexChanged) , this,
-#endif
             &TitleTemplateDialog::updatePreview);
     updatePreview();
 }
 
 QString TitleTemplateDialog::selectedTemplate() const
 {
     QString textTemplate = m_view.template_list->comboBox()->itemData(m_view.template_list->comboBox()->currentIndex()).toString();
     if (textTemplate.isEmpty()) {
         textTemplate = m_view.template_list->comboBox()->currentText();
     }
     return textTemplate;
 }
 
 QString TitleTemplateDialog::selectedText() const
 {
     return m_view.description->toPlainText();
 }
 
 void TitleTemplateDialog::resizeEvent(QResizeEvent *event)
 {
     updatePreview();
     QWidget::resizeEvent(event);
 }
 
 void TitleTemplateDialog::updatePreview()
 {
     QString textTemplate = m_view.template_list->comboBox()->itemData(m_view.template_list->comboBox()->currentIndex()).toString();
     if (textTemplate.isEmpty()) {
         textTemplate = m_view.template_list->comboBox()->currentText();
     }
     QPixmap pix = KThumb::getImage(QUrl::fromLocalFile(textTemplate), m_view.preview->width());
     m_view.preview->setPixmap(pix);
     KdenliveSettings::setSelected_template(m_view.template_list->comboBox()->currentText());
 }
diff --git a/src/dvdwizard/dvdwizardchapters.cpp b/src/dvdwizard/dvdwizardchapters.cpp
index cef5ea3ae..d355acbce 100644
--- a/src/dvdwizard/dvdwizardchapters.cpp
+++ b/src/dvdwizard/dvdwizardchapters.cpp
@@ -1,276 +1,272 @@
 /***************************************************************************
  *   Copyright (C) 2009 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "dvdwizardchapters.h"
 
 DvdWizardChapters::DvdWizardChapters(MonitorManager *manager, DVDFORMAT format, QWidget *parent)
     : QWizardPage(parent)
     , m_format(format)
     , m_monitor(nullptr)
     , m_manager(manager)
 
 {
     m_view.setupUi(this);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_view.vob_list, static_cast<void (KComboBox::*)(int)>(&KComboBox::currentIndexChanged), this, &DvdWizardChapters::slotUpdateChaptersList);
-#else
-    connect(m_view.vob_list, static_cast<void (KComboBox::*)(int, const QString &)>(&KComboBox::currentIndexChanged) , this, &DvdWizardChapters::slotUpdateChaptersList);
-#endif
     connect(m_view.button_add, &QAbstractButton::clicked, this, &DvdWizardChapters::slotAddChapter);
     connect(m_view.button_delete, &QAbstractButton::clicked, this, &DvdWizardChapters::slotRemoveChapter);
     connect(m_view.chapters_list, &QListWidget::itemSelectionChanged, this, &DvdWizardChapters::slotGoToChapter);
     connect(m_view.chapters_box, &QCheckBox::stateChanged, this, &DvdWizardChapters::slotEnableChapters);
     setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 
     // Build monitor for chapters
     auto *vbox = new QVBoxLayout;
     m_view.video_frame->setLayout(vbox);
 
     if (m_format == PAL || m_format == PAL_WIDE) {
         m_tc.setFormat(25);
     } else {
         m_tc.setFormat(30000.0 / 1001);
     }
 }
 
 DvdWizardChapters::~DvdWizardChapters()
 {
     if (m_monitor) {
         m_monitor->stop();
         m_manager->removeMonitor(m_monitor);
         delete m_monitor;
     }
 }
 
 void DvdWizardChapters::stopMonitor()
 {
     if (m_monitor) {
         m_monitor->pause();
     }
 }
 
 void DvdWizardChapters::slotUpdateChaptersList()
 {
     m_monitor->show();
     m_manager->activateMonitor(Kdenlive::DvdMonitor);
     m_monitor->start();
     m_monitor->slotOpenDvdFile(m_view.vob_list->currentText());
     m_monitor->adjustRulerSize(m_view.vob_list->itemData(m_view.vob_list->currentIndex(), Qt::UserRole).toInt());
     QStringList currentChaps = m_view.vob_list->itemData(m_view.vob_list->currentIndex(), Qt::UserRole + 1).toStringList();
     // insert chapters
     QStringList chaptersString;
     for (int i = 0; i < currentChaps.count(); ++i) {
         chaptersString.append(Timecode::getStringTimecode(currentChaps.at(i).toInt(), m_tc.fps(), true));
     }
     m_view.chapters_list->clear();
     m_view.chapters_list->addItems(chaptersString);
     updateMonitorMarkers();
     m_monitor->refreshMonitorIfActive();
     // bool modified = m_view.vob_list->itemData(m_view.vob_list->currentIndex(), Qt::UserRole + 2).toInt();
 }
 
 void DvdWizardChapters::slotAddChapter()
 {
     int pos = m_monitor->position();
     QStringList currentChaps = m_view.vob_list->itemData(m_view.vob_list->currentIndex(), Qt::UserRole + 1).toStringList();
     if (currentChaps.contains(QString::number(pos))) {
         return;
     }
     currentChaps.append(QString::number(pos));
 
     QList<int> chapterTimes;
     chapterTimes.reserve(currentChaps.count());
     for (int i = 0; i < currentChaps.count(); ++i) {
         chapterTimes.append(currentChaps.at(i).toInt());
     }
     std::sort(chapterTimes.begin(), chapterTimes.end());
 
     // rebuild chapters
     QStringList chaptersString;
     currentChaps.clear();
     for (int i = 0; i < chapterTimes.count(); ++i) {
         chaptersString.append(Timecode::getStringTimecode(chapterTimes.at(i), m_tc.fps(), true));
         currentChaps.append(QString::number(chapterTimes.at(i)));
     }
     // Save item chapters
     m_view.vob_list->setItemData(m_view.vob_list->currentIndex(), currentChaps, Qt::UserRole + 1);
     // Mark item as modified
     m_view.vob_list->setItemData(m_view.vob_list->currentIndex(), 1, Qt::UserRole + 2);
     m_view.chapters_list->clear();
     m_view.chapters_list->addItems(chaptersString);
     updateMonitorMarkers();
 }
 
 void DvdWizardChapters::updateMonitorMarkers()
 {
     const QStringList chapters = m_view.vob_list->itemData(m_view.vob_list->currentIndex(), Qt::UserRole + 1).toStringList();
     QList<CommentedTime> markers;
     markers.reserve(chapters.count());
     for (const QString &frame : chapters) {
         markers << CommentedTime(GenTime(frame.toInt(), m_tc.fps()), QString());
     }
     // TODO: reimplement makers as model
     // m_monitor->setMarkers(markers);
 }
 
 void DvdWizardChapters::slotRemoveChapter()
 {
     int ix = m_view.chapters_list->currentRow();
     QStringList currentChaps = m_view.vob_list->itemData(m_view.vob_list->currentIndex(), Qt::UserRole + 1).toStringList();
     currentChaps.removeAt(ix);
 
     // Save item chapters
     m_view.vob_list->setItemData(m_view.vob_list->currentIndex(), currentChaps, Qt::UserRole + 1);
     // Mark item as modified
     m_view.vob_list->setItemData(m_view.vob_list->currentIndex(), 1, Qt::UserRole + 2);
 
     // rebuild chapters
     QStringList chaptersString;
     for (int i = 0; i < currentChaps.count(); ++i) {
         chaptersString.append(Timecode::getStringTimecode(currentChaps.at(i).toInt(), m_tc.fps(), true));
     }
     m_view.chapters_list->clear();
     m_view.chapters_list->addItems(chaptersString);
     updateMonitorMarkers();
 }
 
 void DvdWizardChapters::slotGoToChapter()
 {
     if (m_view.chapters_list->currentItem()) {
         m_monitor->setTimePos(m_tc.reformatSeparators(m_view.chapters_list->currentItem()->text()));
     }
 }
 
 void DvdWizardChapters::createMonitor(DVDFORMAT format)
 {
     if (m_monitor == nullptr) {
         // TODO: allow monitor with different profile for DVD
         QString profile = DvdWizardVob::getDvdProfile(format);
         m_monitor = new Monitor(Kdenlive::DvdMonitor, m_manager, this);
         m_monitor->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
         m_view.video_frame->layout()->addWidget(m_monitor);
         m_manager->appendMonitor(m_monitor);
         m_monitor->setCustomProfile(profile, m_tc);
         m_manager->activateMonitor(Kdenlive::DvdMonitor);
         m_monitor->start();
     }
 }
 
 void DvdWizardChapters::setVobFiles(DVDFORMAT format, const QStringList &movies, const QStringList &durations, const QStringList &chapters)
 {
     m_format = format;
     if (m_format == PAL || m_format == PAL_WIDE) {
         m_tc.setFormat(25);
     } else {
         m_tc.setFormat(30000.0 / 1001);
     }
     m_view.vob_list->blockSignals(true);
     m_view.vob_list->clear();
     for (int i = 0; i < movies.count(); ++i) {
         m_view.vob_list->addItem(movies.at(i), durations.at(i));
         m_view.vob_list->setItemData(i, chapters.at(i).split(QLatin1Char(';')), Qt::UserRole + 1);
     }
     m_view.vob_list->blockSignals(false);
     if (m_view.chapters_box->checkState() == Qt::Checked) {
         slotUpdateChaptersList();
     }
 }
 
 QMap<QString, QString> DvdWizardChapters::chaptersData() const
 {
     QMap<QString, QString> result;
     int max = m_view.vob_list->count();
     for (int i = 0; i < max; ++i) {
         QString chapters = m_view.vob_list->itemData(i, Qt::UserRole + 1).toStringList().join(QLatin1Char(';'));
         result.insert(m_view.vob_list->itemText(i), chapters);
     }
     return result;
 }
 
 QStringList DvdWizardChapters::selectedTitles() const
 {
     QStringList result;
     int max = m_view.vob_list->count();
     for (int i = 0; i < max; ++i) {
         result.append(m_view.vob_list->itemText(i));
         if (!m_view.chapters_box->isChecked()) {
             continue;
         }
         QStringList chapters = m_view.vob_list->itemData(i, Qt::UserRole + 1).toStringList();
         for (int j = 0; j < chapters.count(); ++j) {
             result.append(Timecode::getStringTimecode(chapters.at(j).toInt(), m_tc.fps(), true));
         }
     }
     return result;
 }
 
 QStringList DvdWizardChapters::chapters(int ix) const
 {
     QStringList result;
     QStringList chapters = m_view.vob_list->itemData(ix, Qt::UserRole + 1).toStringList();
     for (int j = 0; j < chapters.count(); ++j) {
         result.append(Timecode::getStringTimecode(chapters.at(j).toInt(), m_tc.fps(), true));
     }
     return result;
 }
 
 QStringList DvdWizardChapters::selectedTargets() const
 {
     QStringList result;
     int max = m_view.vob_list->count();
     for (int i = 0; i < max; ++i) {
         // rightJustified: fill with 0s to make menus with more than 9 buttons work (now up to 99 buttons possible)
         result.append(QStringLiteral("jump title ") + QString::number(i + 1).rightJustified(2, '0'));
         if (!m_view.chapters_box->isChecked()) {
             continue;
         }
         QStringList chapters = m_view.vob_list->itemData(i, Qt::UserRole + 1).toStringList();
         for (int j = 0; j < chapters.count(); ++j) {
             result.append(QStringLiteral("jump title ") + QString::number(i + 1).rightJustified(2, '0') + QStringLiteral(" chapter ") +
                           QString::number(j + 1).rightJustified(2, '0'));
         }
     }
     return result;
 }
 
 QDomElement DvdWizardChapters::toXml() const
 {
     QDomDocument doc;
     QDomElement xml = doc.createElement(QStringLiteral("xml"));
     doc.appendChild(xml);
     if (!m_view.chapters_box->isChecked()) {
         return doc.documentElement();
     }
     for (int i = 0; i < m_view.vob_list->count(); ++i) {
         QDomElement vob = doc.createElement(QStringLiteral("vob"));
         vob.setAttribute(QStringLiteral("file"), m_view.vob_list->itemText(i));
         vob.setAttribute(QStringLiteral("chapters"), m_view.vob_list->itemData(i, Qt::UserRole + 1).toStringList().join(QLatin1Char(';')));
         xml.appendChild(vob);
     }
     return doc.documentElement();
 }
 
 void DvdWizardChapters::slotEnableChapters(int state)
 {
     m_view.chapters_frame->setEnabled(state == Qt::Checked);
     if (state == Qt::Checked) {
         createMonitor(m_format);
         slotUpdateChaptersList();
     }
 }
diff --git a/src/dvdwizard/dvdwizardmenu.cpp b/src/dvdwizard/dvdwizardmenu.cpp
index 4557c9895..ce8ee61e9 100644
--- a/src/dvdwizard/dvdwizardmenu.cpp
+++ b/src/dvdwizard/dvdwizardmenu.cpp
@@ -1,916 +1,912 @@
 /***************************************************************************
  *   Copyright (C) 2009 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "dvdwizardmenu.h"
 
 #include "kdenlivesettings.h"
 
 #include "doc/kthumb.h"
 #include "kdenlive_debug.h"
 #include "klocalizedstring.h"
 #include <KColorScheme>
 #include <QGraphicsDropShadowEffect>
 
 #include <mlt++/MltProducer.h>
 #include <mlt++/MltProfile.h>
 
 enum { DvdButtonItem = QGraphicsItem::UserType + 1, DvdButtonUnderlineItem = QGraphicsItem::UserType + 2 };
 
 DvdScene::DvdScene(QObject *parent)
     : QGraphicsScene(parent)
 
 {
 }
 void DvdScene::setProfile(int width, int height)
 {
     m_width = width;
     m_height = height;
     setSceneRect(0, 0, m_width, m_height);
 }
 
 int DvdScene::gridSize() const
 {
     return m_gridSize;
 }
 
 void DvdScene::setGridSize(int gridSize)
 {
     m_gridSize = gridSize;
 }
 
 void DvdScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
 {
     QGraphicsScene::mouseReleaseEvent(mouseEvent);
     emit sceneChanged();
 }
 
 void DvdScene::drawForeground(QPainter *painter, const QRectF &rect)
 {
     // draw the grid if needed
     if (gridSize() <= 1) {
         return;
     }
 
     QPen pen(QColor(255, 0, 0, 100));
     painter->setPen(pen);
 
     qreal left = int(rect.left()) - (int(rect.left()) % m_gridSize);
     qreal top = int(rect.top()) - (int(rect.top()) % m_gridSize);
     QVector<QPointF> points;
     for (qreal x = left; x < rect.right(); x += m_gridSize) {
         for (qreal y = top; y < rect.bottom(); y += m_gridSize) {
             points.append(QPointF(x, y));
         }
     }
     painter->drawPoints(points.data(), points.size());
 }
 
 DvdButton::DvdButton(const QString &text)
     : QGraphicsTextItem(text)
     , m_target(0)
     , m_command(QStringLiteral("jump title 1"))
     , m_backToMenu(false)
 {
     setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
     setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
 }
 void DvdButton::setTarget(int t, const QString &c)
 {
     m_target = t;
     m_command = c;
 }
 int DvdButton::target() const
 {
     return m_target;
 }
 QString DvdButton::command() const
 {
     return m_command;
 }
 bool DvdButton::backMenu() const
 {
     return m_backToMenu;
 }
 int DvdButton::type() const
 {
     // Enable the use of qgraphicsitem_cast with this item.
     return UserType + 1;
 }
 void DvdButton::setBackMenu(bool back)
 {
     m_backToMenu = back;
 }
 
 QVariant DvdButton::itemChange(GraphicsItemChange change, const QVariant &value)
 {
     if (change == ItemPositionChange && (scene() != nullptr)) {
         QPoint newPos = value.toPoint();
 
         if (QApplication::mouseButtons() == Qt::LeftButton && (qobject_cast<DvdScene *>(scene()) != nullptr)) {
             auto *customScene = qobject_cast<DvdScene *>(scene());
             int gridSize = customScene->gridSize();
             int xV = (newPos.x() / gridSize) * gridSize;
             int yV = (newPos.y() / gridSize) * gridSize;
             newPos = QPoint(xV, yV);
         }
 
         QRectF sceneShape = sceneBoundingRect();
         auto *sc = static_cast<DvdScene *>(scene());
         newPos.setX(qMax(newPos.x(), 0));
         newPos.setY(qMax(newPos.y(), 0));
         if (newPos.x() + sceneShape.width() > sc->width()) {
             newPos.setX(sc->width() - sceneShape.width());
         }
         if (newPos.y() + sceneShape.height() > sc->height()) {
             newPos.setY(sc->height() - sceneShape.height());
         }
 
         sceneShape.translate(newPos - pos());
         QList<QGraphicsItem *> list = scene()->items(sceneShape, Qt::IntersectsItemShape);
         list.removeAll(this);
         if (!list.isEmpty()) {
             for (int i = 0; i < list.count(); ++i) {
                 if (list.at(i)->type() == Type) {
                     return pos();
                 }
             }
         }
         return newPos;
     }
     return QGraphicsItem::itemChange(change, value);
 }
 
 DvdWizardMenu::DvdWizardMenu(DVDFORMAT format, QWidget *parent)
     : QWizardPage(parent)
     , m_color(nullptr)
     , m_safeRect(nullptr)
     , m_finalSize(720, 576)
     , m_movieLength(-1)
 {
     m_view.setupUi(this);
     m_view.play_text->setText(i18n("Play"));
     m_scene = new DvdScene(this);
     m_view.menu_preview->setScene(m_scene);
     m_view.menu_preview->setMouseTracking(true);
     connect(m_view.create_menu, &QAbstractButton::toggled, m_view.menu_box, &QWidget::setEnabled);
     connect(m_view.create_menu, &QAbstractButton::toggled, this, &QWizardPage::completeChanged);
 
     m_view.add_button->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
     m_view.delete_button->setIcon(QIcon::fromTheme(QStringLiteral("trash-empty")));
     m_view.zoom_button->setIcon(QIcon::fromTheme(QStringLiteral("zoom-in")));
     m_view.unzoom_button->setIcon(QIcon::fromTheme(QStringLiteral("zoom-out")));
 
     m_view.add_button->setToolTip(i18n("Add new button"));
     m_view.delete_button->setToolTip(i18n("Delete current button"));
 
     changeProfile(format);
 
     // Create color background
     m_color = new QGraphicsRectItem(0, 0, m_width, m_height);
     m_color->setBrush(m_view.background_color->color());
     m_color->setZValue(2);
     m_scene->addItem(m_color);
 
     // create background image
     m_background = new QGraphicsPixmapItem();
     m_background->setZValue(3);
     // m_scene->addItem(m_background);
 
     // create safe zone rect
     int safeW = m_width / 20;
     int safeH = m_height / 20;
     m_safeRect = new QGraphicsRectItem(safeW, safeH, m_width - 2 * safeW, m_height - 2 * safeH);
     QPen pen(Qt::red);
     pen.setStyle(Qt::DashLine);
     pen.setWidth(3);
     m_safeRect->setPen(pen);
     m_safeRect->setZValue(5);
     m_scene->addItem(m_safeRect);
     checkBackgroundType(0);
 
     // create menu button
     DvdButton *button = new DvdButton(m_view.play_text->text());
     QFont font = m_view.font_family->currentFont();
     font.setPixelSize(m_view.font_size->value());
     // font.setStyleStrategy(QFont::NoAntialias);
     if (m_view.use_shadow->isChecked()) {
         auto *shadow = new QGraphicsDropShadowEffect(this);
         shadow->setBlurRadius(7);
         shadow->setOffset(4, 4);
         button->setGraphicsEffect(shadow);
     }
     connect(m_view.use_shadow, &QCheckBox::stateChanged, this, &DvdWizardMenu::slotEnableShadows);
     button->setFont(font);
     button->setDefaultTextColor(m_view.text_color->color());
     button->setZValue(4);
     QRectF r = button->sceneBoundingRect();
     m_scene->addItem(button);
     button->setPos((m_width - r.width()) / 2, (m_height - r.height()) / 2);
     button->setSelected(true);
 
     if (m_view.use_grid->isChecked()) {
         m_scene->setGridSize(10);
     }
     connect(m_view.use_grid, &QAbstractButton::toggled, this, &DvdWizardMenu::slotUseGrid);
 
     // m_view.menu_preview->resizefitInView(0, 0, m_width, m_height);
 
     connect(m_view.play_text, &QLineEdit::textChanged, this, &DvdWizardMenu::buildButton);
     connect(m_view.text_color, &KColorButton::changed, this, static_cast<void (DvdWizardMenu::*)(const QColor &)>(&DvdWizardMenu::updateColor));
     connect(m_view.font_size, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &DvdWizardMenu::buildButton);
     connect(m_view.font_family, &QFontComboBox::currentFontChanged, this, &DvdWizardMenu::buildButton);
     connect(m_view.background_image, &KUrlRequester::textChanged, this, &DvdWizardMenu::buildImage);
     connect(m_view.background_color, &KColorButton::changed, this, &DvdWizardMenu::buildColor);
 
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_view.background_list, static_cast<void (KComboBox::*)(int)>(&KComboBox::currentIndexChanged), this, &DvdWizardMenu::checkBackgroundType);
-#else
-    connect(m_view.background_list, static_cast<void (KComboBox::*)(int, const QString &)>(&KComboBox::currentIndexChanged) , this, &DvdWizardMenu::checkBackgroundType);
-#endif
 
     connect(m_view.target_list, static_cast<void (KComboBox::*)(int)>(&KComboBox::activated), this, &DvdWizardMenu::setButtonTarget);
     connect(m_view.back_to_menu, &QAbstractButton::toggled, this, &DvdWizardMenu::setBackToMenu);
 
     connect(m_view.add_button, &QAbstractButton::pressed, this, &DvdWizardMenu::addButton);
     connect(m_view.delete_button, &QAbstractButton::pressed, this, &DvdWizardMenu::deleteButton);
     connect(m_view.zoom_button, &QAbstractButton::pressed, this, &DvdWizardMenu::slotZoom);
     connect(m_view.unzoom_button, &QAbstractButton::pressed, this, &DvdWizardMenu::slotUnZoom);
     connect(m_scene, &QGraphicsScene::selectionChanged, this, &DvdWizardMenu::buttonChanged);
     connect(m_scene, &DvdScene::sceneChanged, this, &QWizardPage::completeChanged);
 
     // red background for error message
     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
     QPalette p = m_view.error_message->palette();
     p.setColor(QPalette::Background, scheme.background(KColorScheme::NegativeBackground).color());
     m_view.error_message->setAutoFillBackground(true);
     m_view.error_message->setPalette(p);
     m_view.menu_box->setEnabled(false);
 
     m_menuMessage = new KMessageWidget;
     auto *s = static_cast<QGridLayout *>(layout());
     s->addWidget(m_menuMessage, 7, 0, 1, -1);
     m_menuMessage->hide();
     m_view.error_message->hide();
 }
 
 DvdWizardMenu::~DvdWizardMenu()
 {
     delete m_color;
     delete m_safeRect;
     delete m_background;
     delete m_scene;
 }
 
 void DvdWizardMenu::slotEnableShadows(int enable)
 {
     QList<QGraphicsItem *> list = m_scene->items();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             if (enable != 0) {
                 auto *shadow = new QGraphicsDropShadowEffect(this);
                 shadow->setBlurRadius(7);
                 shadow->setOffset(4, 4);
                 list.at(i)->setGraphicsEffect(shadow);
             } else {
                 list.at(i)->setGraphicsEffect(nullptr);
             }
         }
     }
 }
 
 void DvdWizardMenu::setButtonTarget(int ix)
 {
     QList<QGraphicsItem *> list = m_scene->selectedItems();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             auto *button = static_cast<DvdButton *>(list.at(i));
             button->setTarget(ix, m_view.target_list->itemData(ix).toString());
             break;
         }
     }
     emit completeChanged();
 }
 
 void DvdWizardMenu::setBackToMenu(bool backToMenu)
 {
     QList<QGraphicsItem *> list = m_scene->selectedItems();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             auto *button = static_cast<DvdButton *>(list.at(i));
             button->setBackMenu(backToMenu);
             break;
         }
     }
     emit completeChanged();
 }
 
 void DvdWizardMenu::buttonChanged()
 {
     QList<QGraphicsItem *> list = m_scene->selectedItems();
     bool foundButton = false;
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             m_view.play_text->blockSignals(true);
             m_view.font_size->blockSignals(true);
             m_view.font_family->blockSignals(true);
             m_view.target_list->blockSignals(true);
             m_view.back_to_menu->blockSignals(true);
             foundButton = true;
             m_view.tabWidget->widget(0)->setEnabled(true);
             auto *button = static_cast<DvdButton *>(list.at(i));
             m_view.target_list->setCurrentIndex(button->target());
             m_view.play_text->setText(button->toPlainText());
             m_view.back_to_menu->setChecked(button->backMenu());
             QFont font = button->font();
             m_view.font_size->setValue(font.pixelSize());
             m_view.font_family->setCurrentFont(font);
             m_view.play_text->blockSignals(false);
             m_view.font_size->blockSignals(false);
             m_view.font_family->blockSignals(false);
             m_view.target_list->blockSignals(false);
             m_view.back_to_menu->blockSignals(false);
             break;
         }
     }
     if (!foundButton) {
         m_view.tabWidget->widget(0)->setEnabled(false);
     }
 }
 
 void DvdWizardMenu::addButton()
 {
     m_scene->clearSelection();
     DvdButton *button = new DvdButton(m_view.play_text->text());
     QFont font = m_view.font_family->currentFont();
     font.setPixelSize(m_view.font_size->value());
     if (m_view.use_shadow->isChecked()) {
         auto *shadow = new QGraphicsDropShadowEffect(this);
         shadow->setBlurRadius(7);
         shadow->setOffset(4, 4);
         button->setGraphicsEffect(shadow);
     }
     // font.setStyleStrategy(QFont::NoAntialias);
     button->setFont(font);
     button->setDefaultTextColor(m_view.text_color->color());
     button->setZValue(4);
     QRectF r = button->sceneBoundingRect();
     m_scene->addItem(button);
     button->setPos((m_width - r.width()) / 2, (m_height - r.height()) / 2);
     button->setSelected(true);
 }
 
 void DvdWizardMenu::deleteButton()
 {
     QList<QGraphicsItem *> list = m_scene->selectedItems();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             delete list.at(i);
             break;
         }
     }
 }
 
 void DvdWizardMenu::changeProfile(DVDFORMAT format)
 {
     m_format = format;
     switch (m_format) {
     case PAL_WIDE:
         m_finalSize = QSize(720, 576);
         m_width = 1024;
         m_height = 576;
         break;
     case NTSC_WIDE:
         m_finalSize = QSize(720, 480);
         m_width = 853;
         m_height = 480;
         break;
     case NTSC:
         m_finalSize = QSize(720, 480);
         m_width = 640;
         m_height = 480;
         break;
     default:
         m_finalSize = QSize(720, 576);
         m_width = 768;
         m_height = 576;
     }
     updatePreview();
 }
 
 void DvdWizardMenu::updatePreview()
 {
     m_scene->setProfile(m_width, m_height);
     QMatrix matrix;
     matrix.scale(0.5, 0.5);
     m_view.menu_preview->setMatrix(matrix);
     m_view.menu_preview->setMinimumSize(m_width / 2 + 4, m_height / 2 + 8);
 
     if (m_color) {
         m_color->setRect(0, 0, m_width, m_height);
     }
 
     int safeW = m_width / 20;
     int safeH = m_height / 20;
     if (m_safeRect) {
         m_safeRect->setRect(safeW, safeH, m_width - 2 * safeW, m_height - 2 * safeH);
     }
 }
 
 void DvdWizardMenu::setTargets(const QStringList &list, const QStringList &targetlist)
 {
     m_view.target_list->clear();
     m_view.target_list->addItem(i18n("Play All"), "jump title 1");
     int movieCount = 0;
     for (int i = 0; i < list.count(); ++i) {
         if (targetlist.at(i).contains(QStringLiteral("chapter"))) {
             m_view.target_list->addItem(list.at(i), targetlist.at(i));
         } else {
             m_view.target_list->addItem(QIcon::fromTheme(QStringLiteral("video-x-generic")), list.at(i), targetlist.at(i));
             movieCount++;
         }
     }
     m_view.back_to_menu->setHidden(movieCount == 1);
 }
 
 void DvdWizardMenu::checkBackgroundType(int ix)
 {
     if (ix == 0) {
         m_view.background_color->setVisible(true);
         m_view.background_image->setVisible(false);
         m_view.loop_movie->setVisible(false);
         if (m_background->scene() != nullptr) {
             m_scene->removeItem(m_background);
         }
     } else {
         m_view.background_color->setVisible(false);
         m_view.background_image->setVisible(true);
         if (ix == 1) {
             m_view.background_image->clear();
             m_view.background_image->setFilter(QStringLiteral("*"));
             if (m_background->scene() != nullptr) {
                 m_scene->removeItem(m_background);
             }
             m_view.loop_movie->setVisible(false);
         } else {
             if (m_background->scene() != nullptr) {
                 m_scene->removeItem(m_background);
             }
             m_view.background_image->clear();
             m_view.background_image->setMimeTypeFilters({QStringLiteral("video/mpeg")});
             m_view.loop_movie->setVisible(true);
         }
     }
     emit completeChanged();
 }
 
 void DvdWizardMenu::buildColor()
 {
     m_color->setBrush(m_view.background_color->color());
 }
 
 void DvdWizardMenu::slotUseGrid(bool useGrid)
 {
     if (useGrid) {
         m_scene->setGridSize(10);
     } else {
         m_scene->setGridSize(1);
     }
     m_scene->update();
 }
 
 void DvdWizardMenu::buildImage()
 {
     emit completeChanged();
     if (m_view.background_image->url().isEmpty()) {
         if (m_background->scene() != nullptr) {
             m_scene->removeItem(m_background);
         }
         return;
     }
     QPixmap pix;
 
     if (m_view.background_list->currentIndex() == 1) {
         // image background
         if (!pix.load(m_view.background_image->url().toLocalFile())) {
             if (m_background->scene() != nullptr) {
                 m_scene->removeItem(m_background);
             }
             return;
         }
         pix = pix.scaled(m_width, m_height);
     } else if (m_view.background_list->currentIndex() == 2) {
         // video background
         m_movieLength = -1;
         QString profileName = DvdWizardVob::getDvdProfile(m_format);
         Mlt::Profile profile(profileName.toUtf8().constData());
         profile.set_explicit(1);
         Mlt::Producer *producer = new Mlt::Producer(profile, m_view.background_image->url().toLocalFile().toUtf8().constData());
         if ((producer != nullptr) && producer->is_valid()) {
             pix = QPixmap::fromImage(KThumb::getFrame(producer, 0, m_width, m_height));
             m_movieLength = producer->get_length();
         }
         delete producer;
     }
     m_background->setPixmap(pix);
     m_scene->addItem(m_background);
 }
 
 void DvdWizardMenu::buildButton()
 {
     DvdButton *button = nullptr;
     QList<QGraphicsItem *> list = m_scene->selectedItems();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             button = static_cast<DvdButton *>(list.at(i));
             break;
         }
     }
     if (button == nullptr) {
         return;
     }
     button->setPlainText(m_view.play_text->text());
     QFont font = m_view.font_family->currentFont();
     font.setPixelSize(m_view.font_size->value());
     // font.setStyleStrategy(QFont::NoAntialias);
     button->setFont(font);
     button->setDefaultTextColor(m_view.text_color->color());
     // Check for button overlapping in case we changed text / size
     emit completeChanged();
 }
 
 void DvdWizardMenu::updateColor()
 {
     updateColor(m_view.text_color->color());
     m_view.menu_preview->viewport()->update();
 }
 
 void DvdWizardMenu::prepareUnderLines()
 {
     QList<QGraphicsItem *> list = m_scene->items();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             QRectF r = list.at(i)->sceneBoundingRect();
             int bottom = r.bottom() - 1;
             if (bottom % 2 == 1) {
                 bottom = bottom - 1;
             }
             int underlineHeight = r.height() / 10;
             if (underlineHeight % 2 == 1) {
                 underlineHeight = underlineHeight - 1;
             }
             underlineHeight = qMin(underlineHeight, 10);
             underlineHeight = qMax(underlineHeight, 2);
             r.setTop(bottom - underlineHeight);
             r.setBottom(bottom);
             r.adjust(2, 0, -2, 0);
             auto *underline = new DvdButtonUnderline(r);
             m_scene->addItem(underline);
             list.at(i)->setVisible(false);
         }
     }
 }
 
 void DvdWizardMenu::resetUnderLines()
 {
     QList<QGraphicsItem *> list = m_scene->items();
     QList<QGraphicsItem *> toDelete;
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonUnderlineItem) {
             toDelete.append(list.at(i));
         }
         if (list.at(i)->type() == DvdButtonItem) {
             list.at(i)->setVisible(true);
         }
     }
     while (!toDelete.isEmpty()) {
         QGraphicsItem *item = toDelete.takeFirst();
         delete item;
     }
 }
 
 void DvdWizardMenu::updateUnderlineColor(QColor c)
 {
     QList<QGraphicsItem *> list = m_scene->items();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonUnderlineItem) {
             auto *underline = static_cast<DvdButtonUnderline *>(list.at(i));
             underline->setPen(Qt::NoPen);
             c.setAlpha(150);
             underline->setBrush(c);
         }
     }
 }
 
 void DvdWizardMenu::updateColor(const QColor &c)
 {
     DvdButton *button = nullptr;
     QList<QGraphicsItem *> list = m_scene->items();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             button = static_cast<DvdButton *>(list.at(i));
             button->setDefaultTextColor(c);
         }
     }
 }
 
 void DvdWizardMenu::createButtonImages(const QString &selected_image, const QString &highlighted_image, bool letterbox)
 {
     if (m_view.create_menu->isChecked()) {
         m_scene->clearSelection();
         QRectF source(0, 0, m_width, m_height);
         QRectF target;
         if (!letterbox) {
             target = QRectF(0, 0, m_finalSize.width(), m_finalSize.height());
         } else {
             // Scale the button images to fit a letterbox image
             double factor = (double)m_width / m_finalSize.width();
             int letterboxHeight = m_height / factor;
             target = QRectF(0, (m_finalSize.height() - letterboxHeight) / 2, m_finalSize.width(), letterboxHeight);
         }
         if (m_safeRect->scene() != nullptr) {
             m_scene->removeItem(m_safeRect);
         }
         if (m_color->scene() != nullptr) {
             m_scene->removeItem(m_color);
         }
         if (m_background->scene() != nullptr) {
             m_scene->removeItem(m_background);
         }
         prepareUnderLines();
         QImage img(m_finalSize.width(), m_finalSize.height(), QImage::Format_ARGB32);
         img.fill(Qt::transparent);
         updateUnderlineColor(m_view.highlighted_color->color());
 
         QPainter p;
         p.begin(&img);
         // p.setRenderHints(QPainter::Antialiasing, false);
         // p.setRenderHints(QPainter::TextAntialiasing, false);
         m_scene->render(&p, target, source, Qt::IgnoreAspectRatio);
         p.end();
         img.setColor(0, m_view.highlighted_color->color().rgb());
         img.setColor(1, qRgba(0, 0, 0, 0));
         img.save(highlighted_image);
         img.fill(Qt::transparent);
         updateUnderlineColor(m_view.selected_color->color());
 
         p.begin(&img);
         // p.setRenderHints(QPainter::Antialiasing, false);
         // p.setRenderHints(QPainter::TextAntialiasing, false);
         m_scene->render(&p, target, source, Qt::IgnoreAspectRatio);
         p.end();
         img.setColor(0, m_view.selected_color->color().rgb());
         img.setColor(1, qRgba(0, 0, 0, 0));
         img.save(selected_image);
         resetUnderLines();
         m_scene->addItem(m_safeRect);
         m_scene->addItem(m_color);
         if (m_view.background_list->currentIndex() > 0) {
             m_scene->addItem(m_background);
         }
     }
 }
 
 void DvdWizardMenu::createBackgroundImage(const QString &img1, bool letterbox)
 {
     Q_UNUSED(letterbox)
 
     m_scene->clearSelection();
     if (m_safeRect->scene() != nullptr) {
         m_scene->removeItem(m_safeRect);
     }
     bool showBg = false;
     QImage img(m_width, m_height, QImage::Format_ARGB32);
 
     // TODO: Should the image be scaled when letterboxing?
     /*
     QRectF source(0, 0, m_width, m_height);
     QRectF target;
     if (!letterbox) target = QRectF(0, 0, m_finalSize.width(), m_finalSize.height());
     else {
     // Scale the button images to fit a letterbox image
     double factor = (double) m_width / m_finalSize.width();
     int letterboxHeight = m_height / factor;
     target = QRectF(0, (m_finalSize.height() - letterboxHeight) / 2, m_finalSize.width(), letterboxHeight);
     }*/
 
     if (menuMovie()) {
         showBg = true;
         if (m_background->scene() != nullptr) {
             m_scene->removeItem(m_background);
         }
         if (m_color->scene() != nullptr) {
             m_scene->removeItem(m_color);
         }
         img.fill(Qt::transparent);
     }
     updateColor(m_view.text_color->color());
     QPainter p(&img);
     p.setRenderHints(QPainter::Antialiasing, true);
     p.setRenderHints(QPainter::TextAntialiasing, true);
     // set image grid to "1" to ensure we don't display dots all over
     // the image when rendering
     int oldSize = m_scene->gridSize();
     m_scene->setGridSize(1);
     m_scene->render(&p, QRectF(0, 0, img.width(), img.height()));
     m_scene->setGridSize(oldSize);
     // m_scene->render(&p, target, source, Qt::IgnoreAspectRatio);
     p.end();
     img.save(img1);
     m_scene->addItem(m_safeRect);
     if (showBg) {
         m_scene->addItem(m_background);
         m_scene->addItem(m_color);
     }
 }
 
 bool DvdWizardMenu::createMenu() const
 {
     return m_view.create_menu->isChecked();
 }
 
 bool DvdWizardMenu::loopMovie() const
 {
     return m_view.loop_movie->isChecked();
 }
 
 bool DvdWizardMenu::menuMovie() const
 {
     return m_view.background_list->currentIndex() == 2;
 }
 
 QString DvdWizardMenu::menuMoviePath() const
 {
     return m_view.background_image->url().toLocalFile();
 }
 
 int DvdWizardMenu::menuMovieLength() const
 {
     return m_movieLength;
 }
 
 QMap<QString, QRect> DvdWizardMenu::buttonsInfo(bool letterbox)
 {
     QMap<QString, QRect> info;
     QList<QGraphicsItem *> list = m_scene->items();
     double ratiox = (double)m_finalSize.width() / m_width;
     double ratioy = 1;
     int offset = 0;
     if (letterbox) {
         int letterboxHeight = m_height * ratiox;
         ratioy = (double)letterboxHeight / m_finalSize.height();
         offset = (m_finalSize.height() - letterboxHeight) / 2;
     }
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             auto *button = static_cast<DvdButton *>(list.at(i));
             QRectF r = button->sceneBoundingRect();
             QRect adjustedRect(r.x() * ratiox, offset + r.y() * ratioy, r.width() * ratiox, r.height() * ratioy);
             // Make sure y1 is not odd (requested by spumux)
             if (adjustedRect.height() % 2 == 1) {
                 adjustedRect.setHeight(adjustedRect.height() + 1);
             }
             if (adjustedRect.y() % 2 == 1) {
                 adjustedRect.setY(adjustedRect.y() - 1);
             }
             QString command = button->command();
             if (button->backMenu()) {
                 command.prepend(QStringLiteral("g1 = 999;"));
             }
             info.insertMulti(command, adjustedRect);
         }
     }
     return info;
 }
 
 QDomElement DvdWizardMenu::toXml() const
 {
     QDomDocument doc;
     QDomElement xml = doc.createElement(QStringLiteral("menu"));
     doc.appendChild(xml);
     xml.setAttribute(QStringLiteral("enabled"), static_cast<int>(m_view.create_menu->isChecked()));
     if (m_view.background_list->currentIndex() == 0) {
         // Color bg
         xml.setAttribute(QStringLiteral("background_color"), m_view.background_color->color().name());
     } else if (m_view.background_list->currentIndex() == 1) {
         // Image bg
         xml.setAttribute(QStringLiteral("background_image"), m_view.background_image->url().toLocalFile());
     } else {
         // Video bg
         xml.setAttribute(QStringLiteral("background_video"), m_view.background_image->url().toLocalFile());
     }
     xml.setAttribute(QStringLiteral("text_color"), m_view.text_color->color().name());
     xml.setAttribute(QStringLiteral("selected_color"), m_view.selected_color->color().name());
     xml.setAttribute(QStringLiteral("highlighted_color"), m_view.highlighted_color->color().name());
     xml.setAttribute(QStringLiteral("text_shadow"), (int)m_view.use_shadow->isChecked());
 
     QList<QGraphicsItem *> list = m_scene->items();
     int buttonCount = 0;
 
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->type() == DvdButtonItem) {
             buttonCount++;
             auto *button = static_cast<DvdButton *>(list.at(i));
             QDomElement xmlbutton = doc.createElement(QStringLiteral("button"));
             xmlbutton.setAttribute(QStringLiteral("target"), button->target());
             xmlbutton.setAttribute(QStringLiteral("command"), button->command());
             xmlbutton.setAttribute(QStringLiteral("backtomenu"), static_cast<int>(button->backMenu()));
             xmlbutton.setAttribute(QStringLiteral("posx"), (int)button->pos().x());
             xmlbutton.setAttribute(QStringLiteral("posy"), (int)button->pos().y());
             xmlbutton.setAttribute(QStringLiteral("text"), button->toPlainText());
             QFont font = button->font();
             xmlbutton.setAttribute(QStringLiteral("font_size"), font.pixelSize());
             xmlbutton.setAttribute(QStringLiteral("font_family"), font.family());
             xml.appendChild(xmlbutton);
         }
     }
     return doc.documentElement();
 }
 
 void DvdWizardMenu::loadXml(DVDFORMAT format, const QDomElement &xml)
 {
     // qCDebug(KDENLIVE_LOG) << "// LOADING MENU";
     if (xml.isNull()) {
         return;
     }
     // qCDebug(KDENLIVE_LOG) << "// LOADING MENU 1";
     changeProfile(format);
     m_view.create_menu->setChecked(xml.attribute(QStringLiteral("enabled")).toInt() != 0);
     if (xml.hasAttribute(QStringLiteral("background_color"))) {
         m_view.background_list->setCurrentIndex(0);
         m_view.background_color->setColor(xml.attribute(QStringLiteral("background_color")));
     } else if (xml.hasAttribute(QStringLiteral("background_image"))) {
         m_view.background_list->setCurrentIndex(1);
         m_view.background_image->setUrl(QUrl(xml.attribute(QStringLiteral("background_image"))));
     } else if (xml.hasAttribute(QStringLiteral("background_video"))) {
         m_view.background_list->setCurrentIndex(2);
         m_view.background_image->setUrl(QUrl(xml.attribute(QStringLiteral("background_video"))));
     }
 
     m_view.text_color->setColor(xml.attribute(QStringLiteral("text_color")));
     m_view.selected_color->setColor(xml.attribute(QStringLiteral("selected_color")));
     m_view.highlighted_color->setColor(xml.attribute(QStringLiteral("highlighted_color")));
 
     m_view.use_shadow->setChecked(xml.attribute(QStringLiteral("text_shadow")).toInt() != 0);
 
     QDomNodeList buttons = xml.elementsByTagName(QStringLiteral("button"));
     // qCDebug(KDENLIVE_LOG) << "// LOADING MENU 2" << buttons.count();
 
     if (!buttons.isEmpty()) {
         // Clear existing buttons
         for (QGraphicsItem *item : m_scene->items()) {
             if (item->type() == DvdButtonItem) {
                 m_scene->removeItem(item);
                 delete item;
             }
         }
     }
 
     for (int i = 0; i < buttons.count(); ++i) {
         QDomElement e = buttons.at(i).toElement();
         // create menu button
         DvdButton *button = new DvdButton(e.attribute(QStringLiteral("text")));
         QFont font(e.attribute(QStringLiteral("font_family")));
         font.setPixelSize(e.attribute(QStringLiteral("font_size")).toInt());
         if (m_view.use_shadow->isChecked()) {
             auto *shadow = new QGraphicsDropShadowEffect(this);
             shadow->setBlurRadius(7);
             shadow->setOffset(4, 4);
             button->setGraphicsEffect(shadow);
         }
 
         // font.setStyleStrategy(QFont::NoAntialias);
         button->setFont(font);
         button->setTarget(e.attribute(QStringLiteral("target")).toInt(), e.attribute(QStringLiteral("command")));
         button->setBackMenu(e.attribute(QStringLiteral("backtomenu")).toInt() != 0);
         button->setDefaultTextColor(m_view.text_color->color());
         button->setZValue(4);
         m_scene->addItem(button);
         button->setPos(e.attribute(QStringLiteral("posx")).toInt(), e.attribute(QStringLiteral("posy")).toInt());
     }
 }
 
 void DvdWizardMenu::slotZoom()
 {
     m_view.menu_preview->scale(2.0, 2.0);
 }
 
 void DvdWizardMenu::slotUnZoom()
 {
     m_view.menu_preview->scale(0.5, 0.5);
 }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 83d054340..ef411ea28 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,4041 +1,4037 @@
 /***************************************************************************
  *   Copyright (C) 2007 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "mainwindow.h"
 #include "assets/assetpanel.hpp"
 #include "bin/clipcreator.hpp"
 #include "bin/generators/generators.h"
 #include "bin/projectclip.h"
 #include "bin/projectfolder.h"
 #include "bin/projectitemmodel.h"
 #include "core.h"
 #include "dialogs/clipcreationdialog.h"
 #include "dialogs/kdenlivesettingsdialog.h"
 #include "dialogs/renderwidget.h"
 #include "dialogs/wizard.h"
 #include "doc/docundostack.hpp"
 #include "doc/kdenlivedoc.h"
 #include "effects/effectlist/view/effectlistwidget.hpp"
 #include "effectslist/effectbasket.h"
 #include "hidetitlebars.h"
 #include "jobs/jobmanager.h"
 #include "jobs/scenesplitjob.hpp"
 #include "jobs/speedjob.hpp"
 #include "jobs/stabilizejob.hpp"
 #include "jobs/transcodeclipjob.h"
 #include "kdenlivesettings.h"
 #include "layoutmanagement.h"
 #include "library/librarywidget.h"
 #include "audiomixer/mixermanager.hpp"
 #include "mainwindowadaptor.h"
 #include "mltconnection.h"
 #include "mltcontroller/clipcontroller.h"
 #include "monitor/monitor.h"
 #include "monitor/monitormanager.h"
 #include "monitor/scopes/audiographspectrum.h"
 #include "profiles/profilemodel.hpp"
 #include "project/cliptranscode.h"
 #include "project/dialogs/archivewidget.h"
 #include "project/dialogs/projectsettings.h"
 #include "project/projectcommands.h"
 #include "project/projectmanager.h"
 #include "scopes/scopemanager.h"
 #include "timeline2/view/timelinecontroller.h"
 #include "timeline2/view/timelinetabs.hpp"
 #include "timeline2/view/timelinewidget.h"
 #include "titler/titlewidget.h"
 #include "transitions/transitionlist/view/transitionlistwidget.hpp"
 #include "transitions/transitionsrepository.hpp"
 #include "utils/resourcewidget.h"
 #include "utils/thememanager.h"
 #include "utils/otioconvertions.h"
 
 #include "profiles/profilerepository.hpp"
 #include "widgets/progressbutton.h"
 #include <config-kdenlive.h>
 
 #include "project/dialogs/temporarydata.h"
 
 #ifdef USE_JOGSHUTTLE
 #include "jogshuttle/jogmanager.h"
 #endif
 
 #include <KActionCategory>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KColorScheme>
 #include <KColorSchemeManager>
 #include <KConfigDialog>
 #include <KDualAction>
 #include <KEditToolBar>
 #include <KIconTheme>
 #include <KMessageBox>
 #include <KNotifyConfigWidget>
 #include <KRecentDirs>
 #include <KShortcutsDialog>
 #include <KStandardAction>
 #include <KToolBar>
 #include <KXMLGUIFactory>
 #include <klocalizedstring.h>
 #include <kns3/downloaddialog.h>
 #include <kns3/knewstuffaction.h>
 #include <ktogglefullscreenaction.h>
 
 #include "kdenlive_debug.h"
 #include <QAction>
 #include <QFileDialog>
 #include <QMenu>
 #include <QMenuBar>
 #include <QStatusBar>
 #include <QStyleFactory>
 #include <QUndoGroup>
 #include <KConfigGroup>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QScreen>
 #include <QStandardPaths>
 #include <QVBoxLayout>
 
 static const char version[] = KDENLIVE_VERSION;
 namespace Mlt {
 class Producer;
 }
 
 QMap<QString, QImage> MainWindow::m_lumacache;
 QMap<QString, QStringList> MainWindow::m_lumaFiles;
 
 /*static bool sortByNames(const QPair<QString, QAction *> &a, const QPair<QString, QAction*> &b)
 {
     return a.first < b.first;
 }*/
 
 // determine the default KDE style as defined BY THE USER
 // (as opposed to whatever style KDE considers default)
 static QString defaultStyle(const char *fallback = nullptr)
 {
     KSharedConfigPtr kdeGlobals = KSharedConfig::openConfig(QStringLiteral("kdeglobals"), KConfig::NoGlobals);
     KConfigGroup cg(kdeGlobals, "KDE");
     return cg.readEntry("widgetStyle", fallback);
 }
 
 MainWindow::MainWindow(QWidget *parent)
     : KXmlGuiWindow(parent)
 
 {
 }
 
 void MainWindow::init()
 {
     QString desktopStyle = QApplication::style()->objectName();
     // Load themes
     auto themeManager = new ThemeManager(actionCollection());
     actionCollection()->addAction(QStringLiteral("themes_menu"), themeManager);
     connect(themeManager, &ThemeManager::themeChanged, this, &MainWindow::slotThemeChanged);
 
     if (!KdenliveSettings::widgetstyle().isEmpty() && QString::compare(desktopStyle, KdenliveSettings::widgetstyle(), Qt::CaseInsensitive) != 0) {
         // User wants a custom widget style, init
         doChangeStyle();
     }
 
     // Widget themes for non KDE users
     KActionMenu *stylesAction = new KActionMenu(i18n("Style"), this);
     auto *stylesGroup = new QActionGroup(stylesAction);
 
     // GTK theme does not work well with Kdenlive, and does not support color theming, so avoid it
     QStringList availableStyles = QStyleFactory::keys();
     if (KdenliveSettings::widgetstyle().isEmpty()) {
         // First run
         QStringList incompatibleStyles = {QStringLiteral("GTK+"), QStringLiteral("windowsvista"), QStringLiteral("Windows")};
 
         if (incompatibleStyles.contains(desktopStyle, Qt::CaseInsensitive)) {
             if (availableStyles.contains(QStringLiteral("breeze"), Qt::CaseInsensitive)) {
                 // Auto switch to Breeze theme
                 KdenliveSettings::setWidgetstyle(QStringLiteral("Breeze"));
 		QApplication::setStyle(QStyleFactory::create(QStringLiteral("Breeze")));
             } else if (availableStyles.contains(QStringLiteral("fusion"), Qt::CaseInsensitive)) {
                 KdenliveSettings::setWidgetstyle(QStringLiteral("Fusion"));
 		QApplication::setStyle(QStyleFactory::create(QStringLiteral("Fusion")));
             }
         } else {
             KdenliveSettings::setWidgetstyle(QStringLiteral("Default"));
         }
     }
 
     // Add default style action
     QAction *defaultStyle = new QAction(i18n("Default"), stylesGroup);
     defaultStyle->setData(QStringLiteral("Default"));
     defaultStyle->setCheckable(true);
     stylesAction->addAction(defaultStyle);
     if (KdenliveSettings::widgetstyle() == QLatin1String("Default") || KdenliveSettings::widgetstyle().isEmpty()) {
         defaultStyle->setChecked(true);
     }
 
     for (const QString &style : availableStyles) {
         auto *a = new QAction(style, stylesGroup);
         a->setCheckable(true);
         a->setData(style);
         if (KdenliveSettings::widgetstyle() == style) {
             a->setChecked(true);
         }
         stylesAction->addAction(a);
     }
     connect(stylesGroup, &QActionGroup::triggered, this, &MainWindow::slotChangeStyle);
     // QIcon::setThemeSearchPaths(QStringList() <<QStringLiteral(":/icons/"));
 
     new RenderingAdaptor(this);
     QString defaultProfile = KdenliveSettings::default_profile();
     pCore->setCurrentProfile(defaultProfile.isEmpty() ? ProjectManager::getDefaultProjectFormat() : defaultProfile);
     m_commandStack = new QUndoGroup();
 
     // If using a custom profile, make sure the file exists or fallback to default
     QString currentProfilePath = pCore->getCurrentProfile()->path();
     if (currentProfilePath.startsWith(QLatin1Char('/')) && !QFile::exists(currentProfilePath)) {
         KMessageBox::sorry(this, i18n("Cannot find your default profile, switching to ATSC 1080p 25"));
         pCore->setCurrentProfile(QStringLiteral("atsc_1080p_25"));
         KdenliveSettings::setDefault_profile(QStringLiteral("atsc_1080p_25"));
     }
 
     m_gpuAllowed = EffectsRepository::get()->hasInternalEffect(QStringLiteral("glsl.manager"));
 
     m_shortcutRemoveFocus = new QShortcut(QKeySequence(QStringLiteral("Esc")), this);
     connect(m_shortcutRemoveFocus, &QShortcut::activated, this, &MainWindow::slotRemoveFocus);
 
     /// Add Widgets
     setDockOptions(dockOptions() | QMainWindow::AllowNestedDocks | QMainWindow::AllowTabbedDocks);
     setDockOptions(dockOptions() | QMainWindow::GroupedDragging);
     setTabPosition(Qt::AllDockWidgetAreas, (QTabWidget::TabPosition)KdenliveSettings::tabposition());
     m_timelineToolBar = toolBar(QStringLiteral("timelineToolBar"));
     m_timelineToolBarContainer = new TimelineContainer(this);
     auto *ctnLay = new QVBoxLayout;
     ctnLay->setSpacing(0);
     ctnLay->setContentsMargins(0, 0, 0, 0);
     m_timelineToolBarContainer->setLayout(ctnLay);
     QFrame *topFrame = new QFrame(this);
     topFrame->setFrameShape(QFrame::HLine);
     topFrame->setFixedHeight(1);
     topFrame->setLineWidth(1);
     connect(this, &MainWindow::focusTimeline, [topFrame](bool focus, bool highlight) {
         if (focus) {
             KColorScheme scheme(QApplication::palette().currentColorGroup(), KColorScheme::Tooltip);
             if (highlight) {
                 QColor col = scheme.decoration(KColorScheme::HoverColor).color();
                 topFrame->setStyleSheet(QString("QFrame {border: 1px solid rgba(%1,%2,%3,70)}").arg(col.red()).arg(col.green()).arg(col.blue()));
             } else {
                 QColor col = scheme.decoration(KColorScheme::FocusColor).color();
                 topFrame->setStyleSheet(QString("QFrame {border: 1px solid rgba(%1,%2,%3,100)}").arg(col.red()).arg(col.green()).arg(col.blue()));
             }
         } else {
             topFrame->setStyleSheet(QString());
         }
     });
     ctnLay->addWidget(topFrame);
     ctnLay->addWidget(m_timelineToolBar);
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup mainConfig(config, QStringLiteral("MainWindow"));
     KConfigGroup tbGroup(&mainConfig, QStringLiteral("Toolbar timelineToolBar"));
     m_timelineToolBar->applySettings(tbGroup);
     QFrame *fr = new QFrame(this);
     fr->setFrameShape(QFrame::HLine);
     fr->setMaximumHeight(1);
     fr->setLineWidth(1);
     ctnLay->addWidget(fr);
     setupActions();
 
     QDockWidget *libraryDock = addDock(i18n("Library"), QStringLiteral("library"), pCore->library());
 
     m_clipMonitor = new Monitor(Kdenlive::ClipMonitor, pCore->monitorManager(), this);
     pCore->bin()->setMonitor(m_clipMonitor);
     connect(m_clipMonitor, &Monitor::addMarker, this, &MainWindow::slotAddMarkerGuideQuickly);
     connect(m_clipMonitor, &Monitor::deleteMarker, this, &MainWindow::slotDeleteClipMarker);
     connect(m_clipMonitor, &Monitor::seekToPreviousSnap, this, &MainWindow::slotSnapRewind);
     connect(m_clipMonitor, &Monitor::seekToNextSnap, this, &MainWindow::slotSnapForward);
 
     connect(pCore->bin(), &Bin::findInTimeline, this, &MainWindow::slotClipInTimeline, Qt::DirectConnection);
     connect(pCore->bin(), &Bin::setupTargets, this, [&] (bool hasVideo, QList <int> audioStreams) {
             getCurrentTimeline()->controller()->setTargetTracks(hasVideo, audioStreams);
         }
     );
 
     // TODO deprecated, replace with Bin methods if necessary
     /*connect(m_projectList, SIGNAL(loadingIsOver()), this, SLOT(slotElapsedTime()));
     connect(m_projectList, SIGNAL(updateRenderStatus()), this, SLOT(slotCheckRenderStatus()));
     connect(m_projectList, SIGNAL(updateProfile(QString)), this, SLOT(slotUpdateProjectProfile(QString)));
     connect(m_projectList, SIGNAL(refreshClip(QString,bool)), pCore->monitorManager(), SLOT(slotRefreshCurrentMonitor(QString)));
     connect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), m_projectList, SLOT(slotUpdateClipCut(QPoint)));*/
 
     connect(m_clipMonitor, &Monitor::passKeyPress, this, &MainWindow::triggerKey);
 
     m_projectMonitor = new Monitor(Kdenlive::ProjectMonitor, pCore->monitorManager(), this);
     connect(m_projectMonitor, &Monitor::passKeyPress, this, &MainWindow::triggerKey);
     connect(m_projectMonitor, &Monitor::addMarker, this, &MainWindow::slotAddMarkerGuideQuickly);
     connect(m_projectMonitor, &Monitor::deleteMarker, this, &MainWindow::slotDeleteGuide);
     connect(m_projectMonitor, &Monitor::seekToPreviousSnap, this, &MainWindow::slotSnapRewind);
     connect(m_projectMonitor, &Monitor::seekToNextSnap, this, &MainWindow::slotSnapForward);
     connect(m_loopClip, &QAction::triggered, m_projectMonitor, &Monitor::slotLoopClip);
 
     pCore->monitorManager()->initMonitors(m_clipMonitor, m_projectMonitor);
     connect(m_clipMonitor, &Monitor::addMasterEffect, pCore->bin(), &Bin::slotAddEffect);
 
     m_timelineTabs = new TimelineTabs(this);
     ctnLay->addWidget(m_timelineTabs);
     setCentralWidget(m_timelineToolBarContainer);
 
     // Screen grab widget
     QWidget *grabWidget = new QWidget(this);
     QVBoxLayout *grabLayout = new QVBoxLayout;
     grabWidget->setLayout(grabLayout);
     QToolBar *recToolbar = new QToolBar(grabWidget);
     grabLayout->addWidget(recToolbar);
     grabLayout->addStretch(10);
     // Check number of monitors for FFmpeg screen capture
     int screens = QApplication::screens().count();
     if (screens > 1) {
         QComboBox *screenCombo = new QComboBox(recToolbar);
         for (int ix = 0; ix < screens; ix++) {
             screenCombo->addItem(i18n("Monitor %1", ix));
         }
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         connect(screenCombo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), m_clipMonitor, &Monitor::slotSetScreen);
-#else
-        connect(screenCombo, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , m_clipMonitor, &Monitor::slotSetScreen);
-#endif
         recToolbar->addWidget(screenCombo);
         // Update screen grab monitor choice in case we changed from fullscreen
         screenCombo->setEnabled(KdenliveSettings::grab_capture_type() == 0);
     }
     QAction *recAction = m_clipMonitor->recAction();
     addAction(QStringLiteral("screengrab_record"), recAction);
     recToolbar->addAction(recAction);
     QAction *recConfig = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure Recording"), this);
     recToolbar->addAction(recConfig);
     connect(recConfig, &QAction::triggered, [&]() {
         pCore->showConfigDialog(4, 0);
     });
     QDockWidget *screenGrabDock = addDock(i18n("Screen Grab"), QStringLiteral("screengrab"), grabWidget);
 
     // Audio spectrum scope
     m_audioSpectrum = new AudioGraphSpectrum(pCore->monitorManager());
     QDockWidget *spectrumDock = addDock(i18n("Audio Spectrum"), QStringLiteral("audiospectrum"), m_audioSpectrum);
     // Close library and audiospectrum on first run
     screenGrabDock->close();
     libraryDock->close();
     spectrumDock->close();
 
     m_projectBinDock = addDock(i18n("Project Bin"), QStringLiteral("project_bin"), pCore->bin());
 
     m_assetPanel = new AssetPanel(this);
     m_effectStackDock = addDock(i18n("Effect/Composition Stack"), QStringLiteral("effect_stack"), m_assetPanel);
     connect(m_assetPanel, &AssetPanel::doSplitEffect, m_projectMonitor, &Monitor::slotSwitchCompare);
     connect(m_assetPanel, &AssetPanel::doSplitBinEffect, m_clipMonitor, &Monitor::slotSwitchCompare);
     connect(m_assetPanel, &AssetPanel::switchCurrentComposition, [&](int cid, const QString &compositionId) {
         getMainTimeline()->controller()->getModel()->switchComposition(cid, compositionId);
     });
 
     connect(m_timelineTabs, &TimelineTabs::showTransitionModel, m_assetPanel, &AssetPanel::showTransition);
     connect(m_timelineTabs, &TimelineTabs::showTransitionModel, [&] () {
         m_effectStackDock->raise();
     });
     connect(m_timelineTabs, &TimelineTabs::showItemEffectStack, m_assetPanel, &AssetPanel::showEffectStack);
     connect(m_timelineTabs, &TimelineTabs::showItemEffectStack, [&] () {
         m_effectStackDock->raise();
     });
 
     connect(m_timelineTabs, &TimelineTabs::updateZoom, this, &MainWindow::updateZoomSlider);
     connect(pCore->bin(), &Bin::requestShowEffectStack, m_assetPanel, &AssetPanel::showEffectStack);
     connect(pCore->bin(), &Bin::requestShowEffectStack, [&] () {
         // Don't raise effect stack on clip bin in case it is docked with bin or clip monitor
         // m_effectStackDock->raise();
     });
     connect(this, &MainWindow::clearAssetPanel, m_assetPanel, &AssetPanel::clearAssetPanel);
     connect(this, &MainWindow::assetPanelWarning, m_assetPanel, &AssetPanel::assetPanelWarning);
     connect(m_assetPanel, &AssetPanel::seekToPos, [this](int pos) {
         ObjectId oId = m_assetPanel->effectStackOwner();
         switch (oId.first) {
         case ObjectType::TimelineTrack:
         case ObjectType::TimelineClip:
         case ObjectType::TimelineComposition:
         case ObjectType::Master:
             m_projectMonitor->requestSeek(pos);
             break;
         case ObjectType::BinClip:
             m_clipMonitor->requestSeek(pos);
             break;
         default:
             qDebug() << "ERROR unhandled object type";
             break;
         }
     });
 
     m_effectList2 = new EffectListWidget(this);
     connect(m_effectList2, &EffectListWidget::activateAsset, pCore->projectManager(), &ProjectManager::activateAsset);
     connect(m_assetPanel, &AssetPanel::reloadEffect, m_effectList2, &EffectListWidget::reloadCustomEffect);
     m_effectListDock = addDock(i18n("Effects"), QStringLiteral("effect_list"), m_effectList2);
 
     m_transitionList2 = new TransitionListWidget(this);
     m_transitionListDock = addDock(i18n("Compositions"), QStringLiteral("transition_list"), m_transitionList2);
 
     // Add monitors here to keep them at the right of the window
     m_clipMonitorDock = addDock(i18n("Clip Monitor"), QStringLiteral("clip_monitor"), m_clipMonitor);
     m_projectMonitorDock = addDock(i18n("Project Monitor"), QStringLiteral("project_monitor"), m_projectMonitor);
 
     m_undoView = new QUndoView();
     m_undoView->setCleanIcon(QIcon::fromTheme(QStringLiteral("edit-clear")));
     m_undoView->setEmptyLabel(i18n("Clean"));
     m_undoView->setGroup(m_commandStack);
     m_undoViewDock = addDock(i18n("Undo History"), QStringLiteral("undo_history"), m_undoView);
 
     // Color and icon theme stuff
     connect(m_commandStack, &QUndoGroup::cleanChanged, m_saveAction, &QAction::setDisabled);
     addAction(QStringLiteral("styles_menu"), stylesAction);
 
     QAction *iconAction = new QAction(i18n("Force Breeze Icon Theme"), this);
     iconAction->setCheckable(true);
     iconAction->setChecked(KdenliveSettings::force_breeze());
     addAction(QStringLiteral("force_icon_theme"), iconAction);
     connect(iconAction, &QAction::triggered, this, &MainWindow::forceIconSet);
 
     QDockWidget *mixerDock = addDock(i18n("Audio Mixer"), QStringLiteral("mixer"), pCore->mixer());
     QAction *showMixer = new QAction(QIcon::fromTheme(QStringLiteral("view-media-equalizer")), i18n("Audio Mixer"), this);
     showMixer->setCheckable(true);
     addAction(QStringLiteral("audiomixer_button"), showMixer);
     connect(mixerDock, &QDockWidget::visibilityChanged, [&, showMixer](bool visible) {
         pCore->mixer()->connectMixer(visible);
         showMixer->setChecked(visible);
     });
     connect(showMixer, &QAction::triggered, [&, mixerDock]() {
         if (mixerDock->isVisible() && !mixerDock->visibleRegion().isEmpty()) {
             mixerDock->close();
         } else {
             mixerDock->show();
             mixerDock->raise();
         }
     });
 
     // Close non-general docks for the initial layout
     // only show important ones
     m_undoViewDock->close();
     mixerDock->close();
 
     /// Tabify Widgets
     tabifyDockWidget(m_clipMonitorDock, m_projectMonitorDock);
     tabifyDockWidget(m_transitionListDock, m_effectListDock);
     tabifyDockWidget(m_effectStackDock, pCore->bin()->clipPropertiesDock());
     bool firstRun = readOptions();
 
     // Build effects menu
     m_effectsMenu = new QMenu(i18n("Add Effect"), this);
     m_effectActions = new KActionCategory(i18n("Effects"), actionCollection());
     m_effectList2->reloadEffectMenu(m_effectsMenu, m_effectActions);
 
     m_transitionsMenu = new QMenu(i18n("Add Transition"), this);
     m_transitionActions = new KActionCategory(i18n("Transitions"), actionCollection());
 
     auto *scmanager = new ScopeManager(this);
 
     new LayoutManagement(this);
     new HideTitleBars(this);
     m_extraFactory = new KXMLGUIClient(this);
     buildDynamicActions();
 
     // Create Effect Basket (dropdown list of favorites)
     m_effectBasket = new EffectBasket(this);
     connect(m_effectBasket, &EffectBasket::activateAsset, pCore->projectManager(), &ProjectManager::activateAsset);
     connect(m_effectList2, &EffectListWidget::reloadFavorites, m_effectBasket, &EffectBasket::slotReloadBasket);
     auto *widgetlist = new QWidgetAction(this);
     widgetlist->setDefaultWidget(m_effectBasket);
     // widgetlist->setText(i18n("Favorite Effects"));
     widgetlist->setToolTip(i18n("Favorite Effects"));
     widgetlist->setIcon(QIcon::fromTheme(QStringLiteral("favorite")));
     auto *menu = new QMenu(this);
     menu->addAction(widgetlist);
 
     auto *basketButton = new QToolButton(this);
     basketButton->setMenu(menu);
     basketButton->setToolButtonStyle(toolBar()->toolButtonStyle());
     basketButton->setDefaultAction(widgetlist);
     basketButton->setPopupMode(QToolButton::InstantPopup);
     // basketButton->setText(i18n("Favorite Effects"));
     basketButton->setToolTip(i18n("Favorite Effects"));
     basketButton->setIcon(QIcon::fromTheme(QStringLiteral("favorite")));
 
     auto *toolButtonAction = new QWidgetAction(this);
     toolButtonAction->setText(i18n("Favorite Effects"));
     toolButtonAction->setIcon(QIcon::fromTheme(QStringLiteral("favorite")));
     toolButtonAction->setDefaultWidget(basketButton);
     addAction(QStringLiteral("favorite_effects"), toolButtonAction);
     connect(toolButtonAction, &QAction::triggered, basketButton, &QToolButton::showMenu);
     connect(m_effectBasket, &EffectBasket::activateAsset, menu, &QMenu::close);
 
     // Render button
     ProgressButton *timelineRender = new ProgressButton(i18n("Render"), 100, this);
     auto *tlrMenu = new QMenu(this);
     timelineRender->setMenu(tlrMenu);
     connect(this, &MainWindow::setRenderProgress, timelineRender, &ProgressButton::setProgress);
     auto *renderButtonAction = new QWidgetAction(this);
     renderButtonAction->setText(i18n("Render Button"));
     renderButtonAction->setIcon(QIcon::fromTheme(QStringLiteral("media-record")));
     renderButtonAction->setDefaultWidget(timelineRender);
     addAction(QStringLiteral("project_render_button"), renderButtonAction);
 
     // Timeline preview button
     ProgressButton *timelinePreview = new ProgressButton(i18n("Rendering preview"), 1000, this);
     auto *tlMenu = new QMenu(this);
     timelinePreview->setMenu(tlMenu);
     connect(this, &MainWindow::setPreviewProgress, timelinePreview, &ProgressButton::setProgress);
     auto *previewButtonAction = new QWidgetAction(this);
     previewButtonAction->setText(i18n("Timeline Preview"));
     previewButtonAction->setIcon(QIcon::fromTheme(QStringLiteral("preview-render-on")));
     previewButtonAction->setDefaultWidget(timelinePreview);
     addAction(QStringLiteral("timeline_preview_button"), previewButtonAction);
 
     setupGUI(KXmlGuiWindow::ToolBar | KXmlGuiWindow::StatusBar | KXmlGuiWindow::Save | KXmlGuiWindow::Create);
     if (firstRun) {
         if (QScreen *current = QApplication::primaryScreen()) {
             if (current->availableSize().height() < 1000) {
                 resize(current->availableSize());
             } else {
                 resize(current->availableSize() / 1.5);
             }
         }
     }
     updateActionsToolTip();
     m_timelineToolBar->setToolButtonStyle(Qt::ToolButtonFollowStyle);
     m_timelineToolBar->setProperty("otherToolbar", true);
     timelinePreview->setToolButtonStyle(m_timelineToolBar->toolButtonStyle());
     connect(m_timelineToolBar, &QToolBar::toolButtonStyleChanged, timelinePreview, &ProgressButton::setToolButtonStyle);
 
     timelineRender->setToolButtonStyle(toolBar()->toolButtonStyle());
     /*ScriptingPart* sp = new ScriptingPart(this, QStringList());
     guiFactory()->addClient(sp);*/
 
     loadGenerators();
     loadDockActions();
     loadClipActions();
 
     // Timeline clip menu
     QMenu *timelineClipMenu = new QMenu(this);
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("edit_copy")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("paste_effects")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("group_clip")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("ungroup_clip")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("edit_item_duration")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("clip_split")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("clip_switch")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("delete_timeline_clip")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("extract_clip")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("save_to_bin")));
 
     QMenu *markerMenu = static_cast<QMenu *>(factory()->container(QStringLiteral("marker_menu"), this));
     timelineClipMenu->addMenu(markerMenu);
 
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("set_audio_align_ref")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("align_audio")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("edit_item_speed")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("clip_in_project_tree")));
     timelineClipMenu->addAction(actionCollection()->action(QStringLiteral("cut_timeline_clip")));
 
     // Timeline composition menu
     QMenu *compositionMenu = new QMenu(this);
     compositionMenu->addAction(actionCollection()->action(QStringLiteral("edit_item_duration")));
     compositionMenu->addAction(actionCollection()->action(QStringLiteral("edit_copy")));
     compositionMenu->addAction(actionCollection()->action(QStringLiteral("delete_timeline_clip")));
 
     // Timeline main menu
     QMenu *timelineMenu = new QMenu(this);
     timelineMenu->addAction(actionCollection()->action(QStringLiteral("edit_paste")));
     timelineMenu->addAction(actionCollection()->action(QStringLiteral("insert_space")));
     timelineMenu->addAction(actionCollection()->action(QStringLiteral("delete_space")));
     timelineMenu->addAction(actionCollection()->action(QStringLiteral("delete_space_all_tracks")));
     timelineMenu->addAction(actionCollection()->action(QStringLiteral("add_guide")));
     timelineMenu->addAction(actionCollection()->action(QStringLiteral("edit_guide")));
     QMenu *guideMenu = new QMenu(i18n("Go to Guide..."), this);
     timelineMenu->addMenu(guideMenu);
 
     // Timeline ruler menu
     QMenu *timelineRulerMenu = new QMenu(this);
     timelineRulerMenu->addAction(actionCollection()->action(QStringLiteral("add_guide")));
     timelineRulerMenu->addAction(actionCollection()->action(QStringLiteral("edit_guide")));
     timelineRulerMenu->addMenu(guideMenu);
     timelineRulerMenu->addAction(actionCollection()->action(QStringLiteral("add_project_note")));
 
     // Timeline headers menu
     QMenu *timelineHeadersMenu = new QMenu(this);
     timelineHeadersMenu->addAction(actionCollection()->action(QStringLiteral("insert_track")));
     timelineHeadersMenu->addAction(actionCollection()->action(QStringLiteral("delete_track")));
     timelineHeadersMenu->addAction(actionCollection()->action(QStringLiteral("show_track_record")));
 
     QAction *separate_channels = new QAction(QIcon(), i18n("Separate Channels"), this);
     separate_channels->setCheckable(true);
     separate_channels->setChecked(KdenliveSettings::displayallchannels());
     separate_channels->setData("separate_channels");
     connect(separate_channels, &QAction::triggered, this, &MainWindow::slotSeparateAudioChannel);
     timelineHeadersMenu->addAction(separate_channels);
 
     QMenu *thumbsMenu = new QMenu(i18n("Thumbnails"), this);
     QActionGroup *thumbGroup = new QActionGroup(this);
     QAction *inFrame = new QAction(i18n("In Frame"), thumbGroup);
     inFrame->setData(QStringLiteral("2"));
     inFrame->setCheckable(true);
     thumbsMenu->addAction(inFrame);
     QAction *inOutFrame = new QAction(i18n("In/Out Frames"), thumbGroup);
     inOutFrame->setData(QStringLiteral("0"));
     inOutFrame->setCheckable(true);
     thumbsMenu->addAction(inOutFrame);
     QAction *allFrame = new QAction(i18n("All Frames"), thumbGroup);
     allFrame->setData(QStringLiteral("1"));
     allFrame->setCheckable(true);
     thumbsMenu->addAction(allFrame);
     QAction *noFrame = new QAction(i18n("No Thumbnails"), thumbGroup);
     noFrame->setData(QStringLiteral("3"));
     noFrame->setCheckable(true);
     thumbsMenu->addAction(noFrame);
 
     QMenu *openGLMenu = static_cast<QMenu *>(factory()->container(QStringLiteral("qt_opengl"), this));
 #if defined(Q_OS_WIN)
     connect(openGLMenu, &QMenu::triggered, [&](QAction *ac) {
         KdenliveSettings::setOpengl_backend(ac->data().toInt());
         if (KMessageBox::questionYesNo(this, i18n("Kdenlive needs to be restarted to change this setting. Do you want to proceed?")) != KMessageBox::Yes) {
             return;
         }
         slotRestart(false);
     });
 #else
     if (openGLMenu) {
         openGLMenu->menuAction()->setVisible(false);;
     }
 #endif
     // Connect monitor overlay info menu.
     QMenu *monitorOverlay = static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_config_overlay"), this));
     connect(monitorOverlay, &QMenu::triggered, this, &MainWindow::slotSwitchMonitorOverlay);
 
     m_projectMonitor->setupMenu(static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_go"), this)), monitorOverlay, m_playZone, m_loopZone, nullptr,
                                 m_loopClip);
     m_clipMonitor->setupMenu(static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_go"), this)), monitorOverlay, m_playZone, m_loopZone,
                              static_cast<QMenu *>(factory()->container(QStringLiteral("marker_menu"), this)));
 
     QMenu *clipInTimeline = static_cast<QMenu *>(factory()->container(QStringLiteral("clip_in_timeline"), this));
     clipInTimeline->setIcon(QIcon::fromTheme(QStringLiteral("go-jump")));
     pCore->bin()->setupGeneratorMenu();
 
     connect(pCore->monitorManager(), &MonitorManager::updateOverlayInfos, this, &MainWindow::slotUpdateMonitorOverlays);
 
     // Setup and fill effects and transitions menus.
     QMenu *m = static_cast<QMenu *>(factory()->container(QStringLiteral("video_effects_menu"), this));
     connect(m, &QMenu::triggered, this, &MainWindow::slotAddEffect);
     connect(m_effectsMenu, &QMenu::triggered, this, &MainWindow::slotAddEffect);
     connect(m_transitionsMenu, &QMenu::triggered, this, &MainWindow::slotAddTransition);
 
     m_timelineContextMenu = new QMenu(this);
 
     m_timelineContextMenu->addAction(actionCollection()->action(QStringLiteral("insert_space")));
     m_timelineContextMenu->addAction(actionCollection()->action(QStringLiteral("delete_space")));
     m_timelineContextMenu->addAction(actionCollection()->action(QStringLiteral("delete_space_all_tracks")));
     m_timelineContextMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Paste)));
 
     // QMenu *markersMenu = static_cast<QMenu *>(factory()->container(QStringLiteral("marker_menu"), this));
 
     /*m_timelineClipActions->addMenu(markersMenu);
     m_timelineClipActions->addSeparator();
     m_timelineClipActions->addMenu(m_transitionsMenu);
     m_timelineClipActions->addMenu(m_effectsMenu);*/
 
     slotConnectMonitors();
 
     m_timelineToolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     // TODO: let user select timeline toolbar toolbutton style
     // connect(toolBar(), &QToolBar::iconSizeChanged, m_timelineToolBar, &QToolBar::setToolButtonStyle);
     m_timelineToolBar->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_timelineToolBar, &QWidget::customContextMenuRequested, this, &MainWindow::showTimelineToolbarMenu);
 
     QAction *prevRender = actionCollection()->action(QStringLiteral("prerender_timeline_zone"));
     QAction *stopPrevRender = actionCollection()->action(QStringLiteral("stop_prerender_timeline"));
     tlMenu->addAction(stopPrevRender);
     tlMenu->addAction(actionCollection()->action(QStringLiteral("set_render_timeline_zone")));
     tlMenu->addAction(actionCollection()->action(QStringLiteral("unset_render_timeline_zone")));
     tlMenu->addAction(actionCollection()->action(QStringLiteral("clear_render_timeline_zone")));
 
     // Automatic timeline preview action
     QAction *autoRender = new QAction(QIcon::fromTheme(QStringLiteral("view-refresh")), i18n("Automatic Preview"), this);
     autoRender->setCheckable(true);
     autoRender->setChecked(KdenliveSettings::autopreview());
     connect(autoRender, &QAction::triggered, this, &MainWindow::slotToggleAutoPreview);
     tlMenu->addAction(autoRender);
     tlMenu->addSeparator();
     tlMenu->addAction(actionCollection()->action(QStringLiteral("disable_preview")));
     tlMenu->addAction(actionCollection()->action(QStringLiteral("manage_cache")));
     timelinePreview->defineDefaultAction(prevRender, stopPrevRender);
     timelinePreview->setAutoRaise(true);
 
     QAction *showRender = actionCollection()->action(QStringLiteral("project_render"));
     tlrMenu->addAction(showRender);
     tlrMenu->addAction(actionCollection()->action(QStringLiteral("stop_project_render")));
     timelineRender->defineDefaultAction(showRender, showRender);
     timelineRender->setAutoRaise(true);
 
     // Populate encoding profiles
     KConfig conf(QStringLiteral("encodingprofiles.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     /*KConfig conf(QStringLiteral("encodingprofiles.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     if (KdenliveSettings::proxyparams().isEmpty() || KdenliveSettings::proxyextension().isEmpty()) {
         KConfigGroup group(&conf, "proxy");
         QMap<QString, QString> values = group.entryMap();
         QMapIterator<QString, QString> i(values);
         if (i.hasNext()) {
             i.next();
             QString proxystring = i.value();
             KdenliveSettings::setProxyparams(proxystring.section(QLatin1Char(';'), 0, 0));
             KdenliveSettings::setProxyextension(proxystring.section(QLatin1Char(';'), 1, 1));
         }
     }*/
     if (KdenliveSettings::v4l_parameters().isEmpty() || KdenliveSettings::v4l_extension().isEmpty()) {
         KConfigGroup group(&conf, "video4linux");
         QMap<QString, QString> values = group.entryMap();
         QMapIterator<QString, QString> i(values);
         if (i.hasNext()) {
             i.next();
             QString v4lstring = i.value();
             KdenliveSettings::setV4l_parameters(v4lstring.section(QLatin1Char(';'), 0, 0));
             KdenliveSettings::setV4l_extension(v4lstring.section(QLatin1Char(';'), 1, 1));
         }
     }
     if (KdenliveSettings::grab_parameters().isEmpty() || KdenliveSettings::grab_extension().isEmpty()) {
         KConfigGroup group(&conf, "screengrab");
         QMap<QString, QString> values = group.entryMap();
         QMapIterator<QString, QString> i(values);
         if (i.hasNext()) {
             i.next();
             QString grabstring = i.value();
             KdenliveSettings::setGrab_parameters(grabstring.section(QLatin1Char(';'), 0, 0));
             KdenliveSettings::setGrab_extension(grabstring.section(QLatin1Char(';'), 1, 1));
         }
     }
     if (KdenliveSettings::decklink_parameters().isEmpty() || KdenliveSettings::decklink_extension().isEmpty()) {
         KConfigGroup group(&conf, "decklink");
         QMap<QString, QString> values = group.entryMap();
         QMapIterator<QString, QString> i(values);
         if (i.hasNext()) {
             i.next();
             QString decklinkstring = i.value();
             KdenliveSettings::setDecklink_parameters(decklinkstring.section(QLatin1Char(';'), 0, 0));
             KdenliveSettings::setDecklink_extension(decklinkstring.section(QLatin1Char(';'), 1, 1));
         }
     }
     if (!QDir(KdenliveSettings::currenttmpfolder()).isReadable())
         KdenliveSettings::setCurrenttmpfolder(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
 
     QTimer::singleShot(0, this, &MainWindow::GUISetupDone);
 
 #ifdef USE_JOGSHUTTLE
     new JogManager(this);
 #endif
     getMainTimeline()->setTimelineMenu(timelineClipMenu, compositionMenu, timelineMenu, guideMenu, timelineRulerMenu, actionCollection()->action(QStringLiteral("edit_guide")), timelineHeadersMenu, thumbsMenu);
     scmanager->slotCheckActiveScopes();
     // m_messageLabel->setMessage(QStringLiteral("This is a beta version. Always backup your data"), MltError);
 }
 
 void MainWindow::slotThemeChanged(const QString &name)
 {
     KSharedConfigPtr config = KSharedConfig::openConfig(name);
     QPalette plt = KColorScheme::createApplicationPalette(config);
     // qApp->setPalette(plt);
     // Required for qml palette change
     QGuiApplication::setPalette(plt);
 
     QColor background = plt.window().color();
     bool useDarkIcons = background.value() < 100;
 
     if (m_assetPanel) {
         m_assetPanel->updatePalette();
     }
     if (m_effectList2) {
         // Trigger a repaint to have icons adapted
         m_effectList2->reset();
     }
     if (m_transitionList2) {
         // Trigger a repaint to have icons adapted
         m_transitionList2->reset();
     }
     if (m_clipMonitor) {
         m_clipMonitor->setPalette(plt);
     }
     if (m_projectMonitor) {
         m_projectMonitor->setPalette(plt);
     }
     if (m_timelineTabs) {
         m_timelineTabs->setPalette(plt);
         getMainTimeline()->controller()->resetView();
     }
     if (m_audioSpectrum) {
         m_audioSpectrum->refreshPixmap();
     }
 
     KSharedConfigPtr kconfig = KSharedConfig::openConfig();
     KConfigGroup initialGroup(kconfig, "version");
     if (initialGroup.exists() && KdenliveSettings::force_breeze() && useDarkIcons != KdenliveSettings::use_dark_breeze()) {
         // We need to reload icon theme
         QIcon::setThemeName(useDarkIcons ? QStringLiteral("breeze-dark") : QStringLiteral("breeze"));
         KdenliveSettings::setUse_dark_breeze(useDarkIcons);
     }
 }
 
 void MainWindow::updateActionsToolTip()
 {
     // Add shortcut to action tooltips
     QList<KActionCollection *> collections = KActionCollection::allCollections();
     for (int i = 0; i < collections.count(); ++i) {
         KActionCollection *coll = collections.at(i);
         for (QAction *tempAction : coll->actions()) {
             // find the shortcut pattern and delete (note the preceding space in the RegEx)
             QString strippedTooltip = tempAction->toolTip().remove(QRegExp(QStringLiteral("\\s\\(.*\\)")));
             // append shortcut if it exists for action
             if (tempAction->shortcut() == QKeySequence()) {
                 tempAction->setToolTip(strippedTooltip);
             } else {
                 tempAction->setToolTip(strippedTooltip + QStringLiteral(" (") + tempAction->shortcut().toString() + QLatin1Char(')'));
             }
             connect(tempAction, &QAction::changed, this, &MainWindow::updateAction);
         }
     }
 }
 
 void MainWindow::updateAction()
 {
     auto *action = qobject_cast<QAction *>(sender());
     QString toolTip = KLocalizedString::removeAcceleratorMarker(action->toolTip());
     QString strippedTooltip = toolTip.remove(QRegExp(QStringLiteral("\\s\\(.*\\)")));
     action->setToolTip(i18nc("@info:tooltip Tooltip of toolbar button", "%1 (%2)", strippedTooltip, action->shortcut().toString()));
 }
 
 MainWindow::~MainWindow()
 {
     pCore->prepareShutdown();
     delete m_timelineTabs;
     delete m_audioSpectrum;
     if (m_projectMonitor) {
         m_projectMonitor->stop();
     }
     if (m_clipMonitor) {
         m_clipMonitor->stop();
     }
     ClipController::mediaUnavailable.reset();
     delete m_projectMonitor;
     delete m_clipMonitor;
     delete m_shortcutRemoveFocus;
     delete m_effectList2;
     delete m_transitionList2;
     qDeleteAll(m_transitions);
     // Mlt::Factory::close();
 }
 
 // virtual
 bool MainWindow::queryClose()
 {
     if (m_renderWidget) {
         int waitingJobs = m_renderWidget->waitingJobsCount();
         if (waitingJobs > 0) {
             switch (
                 KMessageBox::warningYesNoCancel(this,
                                                 i18np("You have 1 rendering job waiting in the queue.\nWhat do you want to do with this job?",
                                                       "You have %1 rendering jobs waiting in the queue.\nWhat do you want to do with these jobs?", waitingJobs),
                                                 QString(), KGuiItem(i18n("Start them now")), KGuiItem(i18n("Delete them")))) {
             case KMessageBox::Yes:
                 // create script with waiting jobs and start it
                 if (!m_renderWidget->startWaitingRenderJobs()) {
                     return false;
                 }
                 break;
             case KMessageBox::No:
                 // Don't do anything, jobs will be deleted
                 break;
             default:
                 return false;
             }
         }
     }
     saveOptions();
 
     // WARNING: According to KMainWindow::queryClose documentation we are not supposed to close the document here?
     return pCore->projectManager()->closeCurrentDocument(true, true);
 }
 
 void MainWindow::loadGenerators()
 {
     QMenu *addMenu = static_cast<QMenu *>(factory()->container(QStringLiteral("generators"), this));
     Generators::getGenerators(KdenliveSettings::producerslist(), addMenu);
     connect(addMenu, &QMenu::triggered, this, &MainWindow::buildGenerator);
 }
 
 void MainWindow::buildGenerator(QAction *action)
 {
     Generators gen(action->data().toString(), this);
     if (gen.exec() == QDialog::Accepted) {
         pCore->bin()->slotAddClipToProject(gen.getSavedClip());
     }
 }
 
 void MainWindow::saveProperties(KConfigGroup &config)
 {
     // save properties here
     KXmlGuiWindow::saveProperties(config);
     // TODO: fix session management
     if (qApp->isSavingSession() && pCore->projectManager()) {
         if (pCore->currentDoc() && !pCore->currentDoc()->url().isEmpty()) {
             config.writeEntry("kdenlive_lastUrl", pCore->currentDoc()->url().toLocalFile());
         }
     }
 }
 
 void MainWindow::readProperties(const KConfigGroup &config)
 {
     // read properties here
     KXmlGuiWindow::readProperties(config);
     // TODO: fix session management
     /*if (qApp->isSessionRestored()) {
     pCore->projectManager()->openFile(QUrl::fromLocalFile(config.readEntry("kdenlive_lastUrl", QString())));
     }*/
 }
 
 void MainWindow::saveNewToolbarConfig()
 {
     KXmlGuiWindow::saveNewToolbarConfig();
     // TODO for some reason all dynamically inserted actions are removed by the save toolbar
     // So we currently re-add them manually....
     loadDockActions();
     loadClipActions();
     pCore->bin()->rebuildMenu();
     QMenu *monitorOverlay = static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_config_overlay"), this));
     if (monitorOverlay) {
         m_projectMonitor->setupMenu(static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_go"), this)), monitorOverlay, m_playZone, m_loopZone,
                                     nullptr, m_loopClip);
         m_clipMonitor->setupMenu(static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_go"), this)), monitorOverlay, m_playZone, m_loopZone,
                                  static_cast<QMenu *>(factory()->container(QStringLiteral("marker_menu"), this)));
     }
 }
 
 void MainWindow::slotReloadEffects(const QStringList &paths)
 {
     for (const QString &p : paths) {
         EffectsRepository::get()->reloadCustom(p);
     }
     m_effectList2->reloadEffectMenu(m_effectsMenu, m_effectActions);
 }
 
 void MainWindow::configureNotifications()
 {
     KNotifyConfigWidget::configure(this);
 }
 
 void MainWindow::slotFullScreen()
 {
     KToggleFullScreenAction::setFullScreen(this, actionCollection()->action(QStringLiteral("fullscreen"))->isChecked());
 }
 
 void MainWindow::slotConnectMonitors()
 {
     // connect(m_projectList, SIGNAL(deleteProjectClips(QStringList,QMap<QString,QString>)), this,
     // SLOT(slotDeleteProjectClips(QStringList,QMap<QString,QString>)));
     connect(m_clipMonitor, &Monitor::refreshClipThumbnail, pCore->bin(), &Bin::slotRefreshClipThumbnail);
     connect(m_projectMonitor, &Monitor::requestFrameForAnalysis, this, &MainWindow::slotMonitorRequestRenderFrame);
     connect(m_projectMonitor, &Monitor::createSplitOverlay, this, &MainWindow::createSplitOverlay, Qt::DirectConnection);
     connect(m_projectMonitor, &Monitor::removeSplitOverlay, this, &MainWindow::removeSplitOverlay, Qt::DirectConnection);
 }
 
 void MainWindow::createSplitOverlay(std::shared_ptr<Mlt::Filter> filter)
 {
     if (m_assetPanel->effectStackOwner().first == ObjectType::TimelineClip) {
         getMainTimeline()->controller()->createSplitOverlay(m_assetPanel->effectStackOwner().second, filter);
         m_projectMonitor->activateSplit();
     } else {
         pCore->displayMessage(i18n("Select a clip to compare effect"), InformationMessage);
     }
 }
 
 void MainWindow::removeSplitOverlay()
 {
     getMainTimeline()->controller()->removeSplitOverlay();
 }
 
 void MainWindow::addAction(const QString &name, QAction *action, const QKeySequence &shortcut, KActionCategory *category)
 {
     m_actionNames.append(name);
     if (category) {
         category->addAction(name, action);
     } else {
         actionCollection()->addAction(name, action);
     }
     actionCollection()->setDefaultShortcut(action, shortcut);
 }
 
 QAction *MainWindow::addAction(const QString &name, const QString &text, const QObject *receiver, const char *member, const QIcon &icon,
                                const QKeySequence &shortcut, KActionCategory *category)
 {
     auto *action = new QAction(text, this);
     if (!icon.isNull()) {
         action->setIcon(icon);
     }
     addAction(name, action, shortcut, category);
     connect(action, SIGNAL(triggered(bool)), receiver, member);
 
     return action;
 }
 
 void MainWindow::setupActions()
 {
     // create edit mode buttons
     m_normalEditTool = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-normal-edit")), i18n("Normal mode"), this);
     m_normalEditTool->setCheckable(true);
     m_normalEditTool->setChecked(true);
 
     m_overwriteEditTool = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-overwrite-edit")), i18n("Overwrite mode"), this);
     m_overwriteEditTool->setCheckable(true);
     m_overwriteEditTool->setChecked(false);
 
     m_insertEditTool = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-insert-edit")), i18n("Insert mode"), this);
     m_insertEditTool->setCheckable(true);
     m_insertEditTool->setChecked(false);
 
     KSelectAction *sceneMode = new KSelectAction(i18n("Timeline Edit Mode"), this);
     sceneMode->addAction(m_normalEditTool);
     sceneMode->addAction(m_overwriteEditTool);
     sceneMode->addAction(m_insertEditTool);
     sceneMode->setCurrentItem(0);
     connect(sceneMode, static_cast<void (KSelectAction::*)(QAction *)>(&KSelectAction::triggered), this, &MainWindow::slotChangeEdit);
     addAction(QStringLiteral("timeline_mode"), sceneMode);
 
     m_useTimelineZone = new KDualAction(i18n("Do not Use Timeline Zone for Insert"), i18n("Use Timeline Zone for Insert"), this);
     m_useTimelineZone->setActiveIcon(QIcon::fromTheme(QStringLiteral("timeline-use-zone-on")));
     m_useTimelineZone->setInactiveIcon(QIcon::fromTheme(QStringLiteral("timeline-use-zone-off")));
     m_useTimelineZone->setAutoToggle(true);
     connect(m_useTimelineZone, &KDualAction::activeChangedByUser, this, &MainWindow::slotSwitchTimelineZone);
     addAction(QStringLiteral("use_timeline_zone_in_edit"), m_useTimelineZone);
 
     m_compositeAction = new KSelectAction(QIcon::fromTheme(QStringLiteral("composite-track-off")), i18n("Track compositing"), this);
     m_compositeAction->setToolTip(i18n("Track compositing"));
     QAction *noComposite = new QAction(QIcon::fromTheme(QStringLiteral("composite-track-off")), i18n("None"), this);
     noComposite->setCheckable(true);
     noComposite->setData(0);
     m_compositeAction->addAction(noComposite);
     QString compose = TransitionsRepository::get()->getCompositingTransition();
     if (compose == QStringLiteral("movit.overlay")) {
         // Movit, do not show "preview" option since movit is faster
         QAction *hqComposite = new QAction(QIcon::fromTheme(QStringLiteral("composite-track-on")), i18n("High Quality"), this);
         hqComposite->setCheckable(true);
         hqComposite->setData(2);
         m_compositeAction->addAction(hqComposite);
         m_compositeAction->setCurrentAction(hqComposite);
     } else {
         QAction *previewComposite = new QAction(QIcon::fromTheme(QStringLiteral("composite-track-preview")), i18n("Preview"), this);
         previewComposite->setCheckable(true);
         previewComposite->setData(1);
         m_compositeAction->addAction(previewComposite);
         if (compose != QStringLiteral("composite")) {
             QAction *hqComposite = new QAction(QIcon::fromTheme(QStringLiteral("composite-track-on")), i18n("High Quality"), this);
             hqComposite->setData(2);
             hqComposite->setCheckable(true);
             m_compositeAction->addAction(hqComposite);
             m_compositeAction->setCurrentAction(hqComposite);
         } else {
             m_compositeAction->setCurrentAction(previewComposite);
         }
     }
     connect(m_compositeAction, static_cast<void (KSelectAction::*)(QAction *)>(&KSelectAction::triggered), this, &MainWindow::slotUpdateCompositing);
     addAction(QStringLiteral("timeline_compositing"), m_compositeAction);
 
     QAction *splitView = new QAction(QIcon::fromTheme(QStringLiteral("view-split-top-bottom")), i18n("Split Audio Tracks"), this);
     addAction(QStringLiteral("timeline_view_split"), splitView);
     splitView->setData(QVariant::fromValue(1));
     splitView->setCheckable(true);
     splitView->setChecked(KdenliveSettings::audiotracksbelow() == 1);
 
     QAction *splitView2 = new QAction(QIcon::fromTheme(QStringLiteral("view-split-top-bottom")), i18n("Split Audio Tracks (reverse)"), this);
     addAction(QStringLiteral("timeline_view_split_reverse"), splitView2);
     splitView2->setData(QVariant::fromValue(2));
     splitView2->setCheckable(true);
     splitView2->setChecked(KdenliveSettings::audiotracksbelow() == 2);
 
     QAction *mixedView = new QAction(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Mixed Audio tracks"), this);
     addAction(QStringLiteral("timeline_mixed_view"), mixedView);
     mixedView->setData(QVariant::fromValue(0));
     mixedView->setCheckable(true);
     mixedView->setChecked(KdenliveSettings::audiotracksbelow() == 0);
 
     auto *clipTypeGroup = new QActionGroup(this);
     clipTypeGroup->addAction(mixedView);
     clipTypeGroup->addAction(splitView);
     clipTypeGroup->addAction(splitView2);
     connect(clipTypeGroup, &QActionGroup::triggered, this, &MainWindow::slotUpdateTimelineView);
 
     auto tlsettings = new QMenu(this);
     tlsettings->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     tlsettings->addAction(m_compositeAction);
     tlsettings->addAction(mixedView);
     tlsettings->addAction(splitView);
     tlsettings->addAction(splitView2);
 
     QToolButton *timelineSett = new QToolButton(this);
     timelineSett->setPopupMode(QToolButton::InstantPopup);
     timelineSett->setMenu(tlsettings);
     timelineSett->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     auto *tlButtonAction = new QWidgetAction(this);
     tlButtonAction->setDefaultWidget(timelineSett);
     tlButtonAction->setText(i18n("Track menu"));
     addAction(QStringLiteral("timeline_settings"), tlButtonAction);
 
     m_timeFormatButton = new KSelectAction(QStringLiteral("00:00:00:00 / 00:00:00:00"), this);
     m_timeFormatButton->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
     m_timeFormatButton->addAction(i18n("hh:mm:ss:ff"));
     m_timeFormatButton->addAction(i18n("Frames"));
     if (KdenliveSettings::frametimecode()) {
         m_timeFormatButton->setCurrentItem(1);
     } else {
         m_timeFormatButton->setCurrentItem(0);
     }
     connect(m_timeFormatButton, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &MainWindow::slotUpdateTimecodeFormat);
     m_timeFormatButton->setToolBarMode(KSelectAction::MenuMode);
     m_timeFormatButton->setToolButtonPopupMode(QToolButton::InstantPopup);
     addAction(QStringLiteral("timeline_timecode"), m_timeFormatButton);
 
     // create tools buttons
     m_buttonSelectTool = new QAction(QIcon::fromTheme(QStringLiteral("cursor-arrow")), i18n("Selection tool"), this);
     // toolbar->addAction(m_buttonSelectTool);
     m_buttonSelectTool->setCheckable(true);
     m_buttonSelectTool->setChecked(true);
 
     m_buttonRazorTool = new QAction(QIcon::fromTheme(QStringLiteral("edit-cut")), i18n("Razor tool"), this);
     // toolbar->addAction(m_buttonRazorTool);
     m_buttonRazorTool->setCheckable(true);
     m_buttonRazorTool->setChecked(false);
 
     m_buttonSpacerTool = new QAction(QIcon::fromTheme(QStringLiteral("distribute-horizontal-x")), i18n("Spacer tool"), this);
     // toolbar->addAction(m_buttonSpacerTool);
     m_buttonSpacerTool->setCheckable(true);
     m_buttonSpacerTool->setChecked(false);
     auto *toolGroup = new QActionGroup(this);
     toolGroup->addAction(m_buttonSelectTool);
     toolGroup->addAction(m_buttonRazorTool);
     toolGroup->addAction(m_buttonSpacerTool);
     toolGroup->setExclusive(true);
     
     QAction *collapseItem = new QAction(QIcon::fromTheme(QStringLiteral("collapse-all")), i18n("Collapse/Expand Item"), this);
     addAction(QStringLiteral("collapse_expand"), collapseItem, Qt::Key_Less);
     connect(collapseItem, &QAction::triggered, this, &MainWindow::slotCollapse);
     
     // toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
 
     /*QWidget * actionWidget;
     int max = toolbar->iconSizeDefault() + 2;
     actionWidget = toolbar->widgetForAction(m_normalEditTool);
     actionWidget->setMaximumWidth(max);
     actionWidget->setMaximumHeight(max - 4);
 
     actionWidget = toolbar->widgetForAction(m_insertEditTool);
     actionWidget->setMaximumWidth(max);
     actionWidget->setMaximumHeight(max - 4);
 
     actionWidget = toolbar->widgetForAction(m_overwriteEditTool);
     actionWidget->setMaximumWidth(max);
     actionWidget->setMaximumHeight(max - 4);
 
     actionWidget = toolbar->widgetForAction(m_buttonSelectTool);
     actionWidget->setMaximumWidth(max);
     actionWidget->setMaximumHeight(max - 4);
 
     actionWidget = toolbar->widgetForAction(m_buttonRazorTool);
     actionWidget->setMaximumWidth(max);
     actionWidget->setMaximumHeight(max - 4);
 
     actionWidget = toolbar->widgetForAction(m_buttonSpacerTool);
     actionWidget->setMaximumWidth(max);
     actionWidget->setMaximumHeight(max - 4);*/
 
     connect(toolGroup, &QActionGroup::triggered, this, &MainWindow::slotChangeTool);
 
     m_buttonVideoThumbs = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-show-videothumb")), i18n("Show video thumbnails"), this);
 
     m_buttonVideoThumbs->setCheckable(true);
     m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
     connect(m_buttonVideoThumbs, &QAction::triggered, this, &MainWindow::slotSwitchVideoThumbs);
 
     m_buttonAudioThumbs = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-show-audiothumb")), i18n("Show audio thumbnails"), this);
 
     m_buttonAudioThumbs->setCheckable(true);
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
     connect(m_buttonAudioThumbs, &QAction::triggered, this, &MainWindow::slotSwitchAudioThumbs);
 
     m_buttonShowMarkers = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-show-markers")), i18n("Show markers comments"), this);
 
     m_buttonShowMarkers->setCheckable(true);
     m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
     connect(m_buttonShowMarkers, &QAction::triggered, this, &MainWindow::slotSwitchMarkersComments);
 
     m_buttonSnap = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-snap")), i18n("Snap"), this);
 
     m_buttonSnap->setCheckable(true);
     m_buttonSnap->setChecked(KdenliveSettings::snaptopoints());
     connect(m_buttonSnap, &QAction::triggered, this, &MainWindow::slotSwitchSnap);
 
     m_buttonAutomaticTransition = new QAction(QIcon::fromTheme(QStringLiteral("auto-transition")), i18n("Automatic transitions"), this);
 
     m_buttonAutomaticTransition->setCheckable(true);
     m_buttonAutomaticTransition->setChecked(KdenliveSettings::automatictransitions());
     connect(m_buttonAutomaticTransition, &QAction::triggered, this, &MainWindow::slotSwitchAutomaticTransition);
 
     m_buttonFitZoom = new QAction(QIcon::fromTheme(QStringLiteral("zoom-fit-best")), i18n("Fit zoom to project"), this);
 
     m_buttonFitZoom->setCheckable(false);
 
     m_zoomSlider = new QSlider(Qt::Horizontal, this);
     m_zoomSlider->setRange(0, 20);
     m_zoomSlider->setPageStep(1);
     m_zoomSlider->setInvertedAppearance(true);
     m_zoomSlider->setInvertedControls(true);
 
     m_zoomSlider->setMaximumWidth(150);
     m_zoomSlider->setMinimumWidth(100);
 
     m_zoomIn = KStandardAction::zoomIn(this, SLOT(slotZoomIn()), actionCollection());
     m_zoomOut = KStandardAction::zoomOut(this, SLOT(slotZoomOut()), actionCollection());
 
     connect(m_zoomSlider, SIGNAL(valueChanged(int)), this, SLOT(slotSetZoom(int)));
     connect(m_zoomSlider, &QAbstractSlider::sliderMoved, this, &MainWindow::slotShowZoomSliderToolTip);
     connect(m_buttonFitZoom, &QAction::triggered, this, &MainWindow::slotFitZoom);
 
     KToolBar *toolbar = new KToolBar(QStringLiteral("statusToolBar"), this, Qt::BottomToolBarArea);
     toolbar->setMovable(false);
     toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
 
     if (KdenliveSettings::gpu_accel()) {
     /*QString styleBorderless = QStringLiteral("QToolButton { border-width: 0px;margin: 1px 3px 0px;padding: 0px;}");*/
         QLabel *warnLabel = new QLabel(i18n("Experimental GPU processing enabled - not for production"), this);
         warnLabel->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
     // m_trimLabel->setAutoFillBackground(true);
         warnLabel->setAlignment(Qt::AlignHCenter);
         warnLabel->setStyleSheet(QStringLiteral("QLabel { background-color :red; color:black;padding-left:2px;padding-right:2px}"));
         toolbar->addWidget(warnLabel);
     }
     toolbar->addAction(m_buttonAutomaticTransition);
     toolbar->addAction(m_buttonVideoThumbs);
     toolbar->addAction(m_buttonAudioThumbs);
     toolbar->addAction(m_buttonShowMarkers);
     toolbar->addAction(m_buttonSnap);
     toolbar->addSeparator();
     toolbar->addAction(m_buttonFitZoom);
     toolbar->addAction(m_zoomOut);
     toolbar->addWidget(m_zoomSlider);
     toolbar->addAction(m_zoomIn);
 
     int small = style()->pixelMetric(QStyle::PM_SmallIconSize);
     statusBar()->setMaximumHeight(2 * small);
     m_messageLabel = new StatusBarMessageLabel(this);
     m_messageLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::MinimumExpanding);
     connect(this, &MainWindow::displayMessage, m_messageLabel, &StatusBarMessageLabel::setMessage);
     connect(this, &MainWindow::displayProgressMessage, m_messageLabel, &StatusBarMessageLabel::setProgressMessage);
     statusBar()->addWidget(m_messageLabel, 0);
     QWidget *spacer = new QWidget(this);
     spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
     statusBar()->addWidget(spacer, 1);
     statusBar()->addPermanentWidget(toolbar);
     toolbar->setIconSize(QSize(small, small));
     toolbar->layout()->setContentsMargins(0, 0, 0, 0);
     statusBar()->setContentsMargins(0, 0, 0, 0);
 
     addAction(QStringLiteral("normal_mode"), m_normalEditTool);
     addAction(QStringLiteral("overwrite_mode"), m_overwriteEditTool);
     addAction(QStringLiteral("insert_mode"), m_insertEditTool);
     addAction(QStringLiteral("select_tool"), m_buttonSelectTool, Qt::Key_S);
     addAction(QStringLiteral("razor_tool"), m_buttonRazorTool, Qt::Key_X);
     addAction(QStringLiteral("spacer_tool"), m_buttonSpacerTool, Qt::Key_M);
 
     addAction(QStringLiteral("automatic_transition"), m_buttonAutomaticTransition);
     addAction(QStringLiteral("show_video_thumbs"), m_buttonVideoThumbs);
     addAction(QStringLiteral("show_audio_thumbs"), m_buttonAudioThumbs);
     addAction(QStringLiteral("show_markers"), m_buttonShowMarkers);
     addAction(QStringLiteral("snap"), m_buttonSnap);
     addAction(QStringLiteral("zoom_fit"), m_buttonFitZoom);
 
 #if defined(Q_OS_WIN)
     int glBackend = KdenliveSettings::opengl_backend();
     QAction *openGLAuto = new QAction(i18n("Auto"), this);
     openGLAuto->setData(0);
     openGLAuto->setCheckable(true);
     openGLAuto->setChecked(glBackend == 0);
 
     QAction *openGLDesktop = new QAction(i18n("OpenGL"), this);
     openGLDesktop->setData(Qt::AA_UseDesktopOpenGL);
     openGLDesktop->setCheckable(true);
     openGLDesktop->setChecked(glBackend == Qt::AA_UseDesktopOpenGL);
 
     QAction *openGLES = new QAction(i18n("DirectX (ANGLE)"), this);
     openGLES->setData(Qt::AA_UseOpenGLES);
     openGLES->setCheckable(true);
     openGLES->setChecked(glBackend == Qt::AA_UseOpenGLES);
 
     QAction *openGLSoftware = new QAction(i18n("Software OpenGL"), this);
     openGLSoftware->setData(Qt::AA_UseSoftwareOpenGL);
     openGLSoftware->setCheckable(true);
     openGLSoftware->setChecked(glBackend == Qt::AA_UseSoftwareOpenGL);
     addAction(QStringLiteral("opengl_auto"), openGLAuto);
     addAction(QStringLiteral("opengl_desktop"), openGLDesktop);
     addAction(QStringLiteral("opengl_es"), openGLES);
     addAction(QStringLiteral("opengl_software"), openGLSoftware);
 #endif
 
     addAction(QStringLiteral("run_wizard"), i18n("Run Config Wizard"), this, SLOT(slotRunWizard()), QIcon::fromTheme(QStringLiteral("tools-wizard")));
     addAction(QStringLiteral("project_settings"), i18n("Project Settings"), this, SLOT(slotEditProjectSettings()),
               QIcon::fromTheme(QStringLiteral("configure")));
 
     addAction(QStringLiteral("project_render"), i18n("Render"), this, SLOT(slotRenderProject()), QIcon::fromTheme(QStringLiteral("media-record")),
               Qt::CTRL + Qt::Key_Return);
 
     addAction(QStringLiteral("stop_project_render"), i18n("Stop Render"), this, SLOT(slotStopRenderProject()),
               QIcon::fromTheme(QStringLiteral("media-record")));
 
     addAction(QStringLiteral("project_clean"), i18n("Clean Project"), this, SLOT(slotCleanProject()), QIcon::fromTheme(QStringLiteral("edit-clear")));
 
     QAction *resetAction = new QAction(QIcon::fromTheme(QStringLiteral("reload")), i18n("Reset configuration"), this);
     addAction(QStringLiteral("reset_config"), resetAction);
     connect(resetAction, &QAction::triggered, [&]() {
         slotRestart(true);
     });
 
     addAction("project_adjust_profile", i18n("Adjust Profile to Current Clip"), pCore->bin(), SLOT(adjustProjectProfileToItem()));
 
     m_playZone = addAction(QStringLiteral("monitor_play_zone"), i18n("Play Zone"), pCore->monitorManager(), SLOT(slotPlayZone()),
                            QIcon::fromTheme(QStringLiteral("media-playback-start")), Qt::CTRL + Qt::Key_Space);
     m_loopZone = addAction(QStringLiteral("monitor_loop_zone"), i18n("Loop Zone"), pCore->monitorManager(), SLOT(slotLoopZone()),
                            QIcon::fromTheme(QStringLiteral("media-playback-start")), Qt::ALT + Qt::Key_Space);
     m_loopClip = new QAction(QIcon::fromTheme(QStringLiteral("media-playback-start")), i18n("Loop selected clip"), this);
     addAction(QStringLiteral("monitor_loop_clip"), m_loopClip);
     m_loopClip->setEnabled(false);
 
     addAction(QStringLiteral("dvd_wizard"), i18n("DVD Wizard"), this, SLOT(slotDvdWizard()), QIcon::fromTheme(QStringLiteral("media-optical")));
     addAction(QStringLiteral("transcode_clip"), i18n("Transcode Clips"), this, SLOT(slotTranscodeClip()), QIcon::fromTheme(QStringLiteral("edit-copy")));
     QAction *exportAction = new QAction(QIcon::fromTheme(QStringLiteral("document-export")), i18n("E&xport project"), this);
     connect(exportAction, &QAction::triggered, &m_otioConvertions, &OtioConvertions::slotExportProject);
     addAction(QStringLiteral("export_project"), exportAction);
     QAction *importAction = new QAction(QIcon::fromTheme(QStringLiteral("document-import")), i18n("&Import project"), this);
     connect(importAction, &QAction::triggered, &m_otioConvertions, &OtioConvertions::slotImportProject);
     addAction(QStringLiteral("import_project"), importAction);
 
     addAction(QStringLiteral("archive_project"), i18n("Archive Project"), this, SLOT(slotArchiveProject()),
               QIcon::fromTheme(QStringLiteral("document-save-all")));
     addAction(QStringLiteral("switch_monitor"), i18n("Switch monitor"), this, SLOT(slotSwitchMonitors()), QIcon(), Qt::Key_T);
     addAction(QStringLiteral("expand_timeline_clip"), i18n("Expand Clip"), this, SLOT(slotExpandClip()),
               QIcon::fromTheme(QStringLiteral("document-open")));
 
     QAction *overlayInfo = new QAction(QIcon::fromTheme(QStringLiteral("help-hint")), i18n("Monitor Info Overlay"), this);
     addAction(QStringLiteral("monitor_overlay"), overlayInfo);
     overlayInfo->setCheckable(true);
     overlayInfo->setData(0x01);
 
     QAction *overlayTCInfo = new QAction(QIcon::fromTheme(QStringLiteral("help-hint")), i18n("Monitor Overlay Timecode"), this);
     addAction(QStringLiteral("monitor_overlay_tc"), overlayTCInfo);
     overlayTCInfo->setCheckable(true);
     overlayTCInfo->setData(0x02);
 
     QAction *overlayFpsInfo = new QAction(QIcon::fromTheme(QStringLiteral("help-hint")), i18n("Monitor Overlay Playback Fps"), this);
     addAction(QStringLiteral("monitor_overlay_fps"), overlayFpsInfo);
     overlayFpsInfo->setCheckable(true);
     overlayFpsInfo->setData(0x20);
 
     QAction *overlayMarkerInfo = new QAction(QIcon::fromTheme(QStringLiteral("help-hint")), i18n("Monitor Overlay Markers"), this);
     addAction(QStringLiteral("monitor_overlay_markers"), overlayMarkerInfo);
     overlayMarkerInfo->setCheckable(true);
     overlayMarkerInfo->setData(0x04);
 
     QAction *overlayAudioInfo = new QAction(QIcon::fromTheme(QStringLiteral("help-hint")), i18n("Monitor Overlay Audio Waveform"), this);
     addAction(QStringLiteral("monitor_overlay_audiothumb"), overlayAudioInfo);
     overlayAudioInfo->setCheckable(true);
     overlayAudioInfo->setData(0x10);
 
     connect(overlayInfo, &QAction::toggled, [&, overlayTCInfo, overlayFpsInfo, overlayMarkerInfo, overlayAudioInfo](bool toggled) {
         overlayTCInfo->setEnabled(toggled);
         overlayFpsInfo->setEnabled(toggled);
         overlayMarkerInfo->setEnabled(toggled);
         overlayAudioInfo->setEnabled(toggled);
     });
 
 #if LIBMLT_VERSION_INT >= MLT_VERSION_PREVIEW_SCALE
     // Monitor resolution scaling
     m_scaleGroup = new QActionGroup(this);
     m_scaleGroup->setExclusive(true);
     m_scaleGroup->setEnabled(!KdenliveSettings::external_display());
     QAction *scale_no = new QAction(i18n("Full Resolution (1:1)"), m_scaleGroup);
     addAction(QStringLiteral("scale_no_preview"), scale_no);
     scale_no->setCheckable(true);
     scale_no->setData(1);
     QAction *scale_2 = new QAction(i18n("720p"), m_scaleGroup);
     addAction(QStringLiteral("scale_2_preview"), scale_2);
     scale_2->setCheckable(true);
     scale_2->setData(2);
     QAction *scale_4 = new QAction(i18n("540p"), m_scaleGroup);
     addAction(QStringLiteral("scale_4_preview"), scale_4);
     scale_4->setCheckable(true);
     scale_4->setData(4);
     QAction *scale_8 = new QAction(i18n("360p"), m_scaleGroup);
     addAction(QStringLiteral("scale_8_preview"), scale_8);
     scale_8->setCheckable(true);
     scale_8->setData(8);
     QAction *scale_16 = new QAction(i18n("270p"), m_scaleGroup);
     addAction(QStringLiteral("scale_16_preview"), scale_16);
     scale_16->setCheckable(true);
     scale_16->setData(16);
     connect(pCore->monitorManager(), &MonitorManager::scalingChanged, [scale_2, scale_4, scale_8, scale_16, scale_no]() {
         switch (KdenliveSettings::previewScaling()) {
             case 2:
                 scale_2->setChecked(true);
                 break;
             case 4:
                 scale_4->setChecked(true);
                 break;
             case 8:
                 scale_8->setChecked(true);
                 break;
             case 16:
                 scale_16->setChecked(true);
                 break;
             default:
                 scale_no->setChecked(true);
                 break;
         }
     });
     pCore->monitorManager()->scalingChanged();
     connect(m_scaleGroup, &QActionGroup::triggered, [] (QAction *ac) {
         int scaling = ac->data().toInt();
         KdenliveSettings::setPreviewScaling(scaling);
         // Clear timeline selection so that any qml monitor scene is reset
         pCore->monitorManager()->updatePreviewScaling();
     });
 #endif
 
     QAction *dropFrames = new QAction(QIcon(), i18n("Real Time (drop frames)"), this);
     dropFrames->setCheckable(true);
     dropFrames->setChecked(KdenliveSettings::monitor_dropframes());
     addAction(QStringLiteral("mlt_realtime"), dropFrames);
     connect(dropFrames, &QAction::toggled, this, &MainWindow::slotSwitchDropFrames);
 
     KSelectAction *monitorGamma = new KSelectAction(i18n("Monitor Gamma"), this);
     monitorGamma->addAction(i18n("sRGB (computer)"));
     monitorGamma->addAction(i18n("Rec. 709 (TV)"));
     addAction(QStringLiteral("mlt_gamma"), monitorGamma);
     monitorGamma->setCurrentItem(KdenliveSettings::monitor_gamma());
     connect(monitorGamma, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &MainWindow::slotSetMonitorGamma);
 
     addAction(QStringLiteral("switch_trim"), i18n("Trim Mode"), this, SLOT(slotSwitchTrimMode()), QIcon::fromTheme(QStringLiteral("cursor-arrow")));
     // disable shortcut until fully working, Qt::CTRL + Qt::Key_T);
 
     addAction(QStringLiteral("insert_project_tree"), i18n("Insert Zone in Project Bin"), this, SLOT(slotInsertZoneToTree()),
               QIcon::fromTheme(QStringLiteral("kdenlive-add-clip")), Qt::CTRL + Qt::Key_I);
 
     addAction(QStringLiteral("monitor_seek_snap_backward"), i18n("Go to Previous Snap Point"), this, SLOT(slotSnapRewind()),
               QIcon::fromTheme(QStringLiteral("media-seek-backward")), Qt::ALT + Qt::Key_Left);
     addAction(QStringLiteral("monitor_seek_guide_backward"), i18n("Go to Previous Guide"), this, SLOT(slotGuideRewind()),
               QIcon::fromTheme(QStringLiteral("media-seek-backward")), Qt::CTRL + Qt::Key_Left);
     addAction(QStringLiteral("seek_clip_start"), i18n("Go to Clip Start"), this, SLOT(slotClipStart()), QIcon::fromTheme(QStringLiteral("media-seek-backward")),
               Qt::Key_Home);
     addAction(QStringLiteral("seek_clip_end"), i18n("Go to Clip End"), this, SLOT(slotClipEnd()), QIcon::fromTheme(QStringLiteral("media-seek-forward")),
               Qt::Key_End);
     addAction(QStringLiteral("monitor_seek_snap_forward"), i18n("Go to Next Snap Point"), this, SLOT(slotSnapForward()),
               QIcon::fromTheme(QStringLiteral("media-seek-forward")), Qt::ALT + Qt::Key_Right);
     addAction(QStringLiteral("monitor_seek_guide_forward"), i18n("Go to Next Guide"), this, SLOT(slotGuideForward()),
               QIcon::fromTheme(QStringLiteral("media-seek-forward")), Qt::CTRL + Qt::Key_Right);
     addAction(QStringLiteral("align_playhead"), i18n("Align Playhead to Mouse Position"), this, SLOT(slotAlignPlayheadToMousePos()), QIcon(), Qt::Key_P);
 
     addAction(QStringLiteral("grab_item"), i18n("Grab Current Item"), this, SLOT(slotGrabItem()), QIcon::fromTheme(QStringLiteral("transform-move")),
               Qt::SHIFT + Qt::Key_G);
 
     QAction *stickTransition = new QAction(i18n("Automatic Transition"), this);
     stickTransition->setData(QStringLiteral("auto"));
     stickTransition->setCheckable(true);
     stickTransition->setEnabled(false);
     addAction(QStringLiteral("auto_transition"), stickTransition);
     connect(stickTransition, &QAction::triggered, this, &MainWindow::slotAutoTransition);
 
     addAction(QStringLiteral("overwrite_to_in_point"), i18n("Overwrite Clip Zone in Timeline"), this, SLOT(slotInsertClipOverwrite()),
               QIcon::fromTheme(QStringLiteral("timeline-overwrite")), Qt::Key_B);
     addAction(QStringLiteral("insert_to_in_point"), i18n("Insert Clip Zone in Timeline"), this, SLOT(slotInsertClipInsert()),
               QIcon::fromTheme(QStringLiteral("timeline-insert")), Qt::Key_V);
     addAction(QStringLiteral("remove_extract"), i18n("Extract Timeline Zone"), this, SLOT(slotExtractZone()),
               QIcon::fromTheme(QStringLiteral("timeline-extract")), Qt::SHIFT + Qt::Key_X);
     addAction(QStringLiteral("remove_lift"), i18n("Lift Timeline Zone"), this, SLOT(slotLiftZone()), QIcon::fromTheme(QStringLiteral("timeline-lift")),
               Qt::Key_Z);
     addAction(QStringLiteral("set_render_timeline_zone"), i18n("Add Preview Zone"), this, SLOT(slotDefinePreviewRender()),
               QIcon::fromTheme(QStringLiteral("preview-add-zone")));
     addAction(QStringLiteral("unset_render_timeline_zone"), i18n("Remove Preview Zone"), this, SLOT(slotRemovePreviewRender()),
               QIcon::fromTheme(QStringLiteral("preview-remove-zone")));
     addAction(QStringLiteral("clear_render_timeline_zone"), i18n("Remove All Preview Zones"), this, SLOT(slotClearPreviewRender()),
               QIcon::fromTheme(QStringLiteral("preview-remove-all")));
     addAction(QStringLiteral("prerender_timeline_zone"), i18n("Start Preview Render"), this, SLOT(slotPreviewRender()),
               QIcon::fromTheme(QStringLiteral("preview-render-on")), QKeySequence(Qt::SHIFT + Qt::Key_Return));
     addAction(QStringLiteral("stop_prerender_timeline"), i18n("Stop Preview Render"), this, SLOT(slotStopPreviewRender()),
               QIcon::fromTheme(QStringLiteral("preview-render-off")));
 
     addAction(QStringLiteral("select_timeline_clip"), i18n("Select Clip"), this, SLOT(slotSelectTimelineClip()),
               QIcon::fromTheme(QStringLiteral("edit-select")), Qt::Key_Plus);
     addAction(QStringLiteral("deselect_timeline_clip"), i18n("Deselect Clip"), this, SLOT(slotDeselectTimelineClip()),
               QIcon::fromTheme(QStringLiteral("edit-select")), Qt::Key_Minus);
     addAction(QStringLiteral("select_add_timeline_clip"), i18n("Add Clip To Selection"), this, SLOT(slotSelectAddTimelineClip()),
               QIcon::fromTheme(QStringLiteral("edit-select")), Qt::ALT + Qt::Key_Plus);
     addAction(QStringLiteral("select_timeline_transition"), i18n("Select Transition"), this, SLOT(slotSelectTimelineTransition()),
               QIcon::fromTheme(QStringLiteral("edit-select")), Qt::SHIFT + Qt::Key_Plus);
     addAction(QStringLiteral("deselect_timeline_transition"), i18n("Deselect Transition"), this, SLOT(slotDeselectTimelineTransition()),
               QIcon::fromTheme(QStringLiteral("edit-select")), Qt::SHIFT + Qt::Key_Minus);
     addAction(QStringLiteral("select_add_timeline_transition"), i18n("Add Transition To Selection"), this, SLOT(slotSelectAddTimelineTransition()),
               QIcon::fromTheme(QStringLiteral("edit-select")), Qt::ALT + Qt::SHIFT + Qt::Key_Plus);
 
     addAction(QStringLiteral("delete_all_clip_markers"), i18n("Delete All Markers"), this, SLOT(slotDeleteAllClipMarkers()),
               QIcon::fromTheme(QStringLiteral("edit-delete")));
     addAction(QStringLiteral("add_marker_guide_quickly"), i18n("Add Marker/Guide quickly"), this, SLOT(slotAddMarkerGuideQuickly()),
               QIcon::fromTheme(QStringLiteral("bookmark-new")), Qt::Key_Asterisk);
 
     // Clip actions. We set some category info on the action data to enable/disable it contextually in timelinecontroller
     KActionCategory *clipActionCategory = new KActionCategory(i18n("Current Selection"), actionCollection());
 
     QAction *addMarker = addAction(QStringLiteral("add_clip_marker"), i18n("Add Marker"), this, SLOT(slotAddClipMarker()), QIcon::fromTheme(QStringLiteral("bookmark-new")), QKeySequence(), clipActionCategory);
     addMarker->setData('P');
 
     QAction *delMarker = addAction(QStringLiteral("delete_clip_marker"), i18n("Delete Marker"), this, SLOT(slotDeleteClipMarker()), QIcon::fromTheme(QStringLiteral("edit-delete")), QKeySequence(), clipActionCategory);
     delMarker->setData('P');
 
     QAction *editClipMarker = addAction(QStringLiteral("edit_clip_marker"), i18n("Edit Marker"), this, SLOT(slotEditClipMarker()),
                                         QIcon::fromTheme(QStringLiteral("document-properties")), QKeySequence(), clipActionCategory);
     editClipMarker->setObjectName(QStringLiteral("edit_marker"));
     editClipMarker->setData('P');
 
     QAction *splitAudio = addAction(QStringLiteral("clip_split"), i18n("Split Audio"), this, SLOT(slotSplitAV()),
                                     QIcon::fromTheme(QStringLiteral("document-new")), QKeySequence(), clipActionCategory);
     // "S" will be handled specifically to change the action name depending on current selection
     splitAudio->setData('S');
     splitAudio->setEnabled(false);
 
     QAction *extractClip = addAction(QStringLiteral("extract_clip"), i18n("Extract Clip"), this, SLOT(slotExtractClip()), QIcon::fromTheme(QStringLiteral("timeline-extract")), QKeySequence(), clipActionCategory);
     extractClip->setData('C');
     extractClip->setEnabled(false);
 
     QAction *extractToBin = addAction(QStringLiteral("save_to_bin"), i18n("Save Timeline Zone to Bin"), this, SLOT(slotSaveZoneToBin()), QIcon(), QKeySequence(), clipActionCategory);
     extractToBin->setData('C');
     extractToBin->setEnabled(false);
 
     QAction *switchEnable = addAction(QStringLiteral("clip_switch"), i18n("Disable Clip"), this, SLOT(slotSwitchClip()),
                                     QIcon(), QKeySequence(), clipActionCategory);
     // "W" will be handled specifically to change the action name depending on current selection
     switchEnable->setData('W');
     switchEnable->setEnabled(false);
 
     QAction *setAudioAlignReference = addAction(QStringLiteral("set_audio_align_ref"), i18n("Set Audio Reference"), this, SLOT(slotSetAudioAlignReference()),
                                                 QIcon(), QKeySequence(), clipActionCategory);
     // "A" as data means this action should only be available for clips with audio
     setAudioAlignReference->setData('A');
     setAudioAlignReference->setEnabled(false);
 
     QAction *alignAudio =
         addAction(QStringLiteral("align_audio"), i18n("Align Audio to Reference"), this, SLOT(slotAlignAudio()), QIcon(), QKeySequence(), clipActionCategory);
     // "A" as data means this action should only be available for clips with audio
     //alignAudio->setData('A');
     alignAudio->setEnabled(false);
 
     QAction *act = addAction(QStringLiteral("edit_item_duration"), i18n("Edit Duration"), this, SLOT(slotEditItemDuration()),
                              QIcon::fromTheme(QStringLiteral("measure")), QKeySequence(), clipActionCategory);
     act->setEnabled(false);
 
     act = addAction(QStringLiteral("edit_item_speed"), i18n("Change Speed"), this, SLOT(slotEditItemSpeed()),
                              QIcon::fromTheme(QStringLiteral("speedometer")), QKeySequence(), clipActionCategory);
     act->setEnabled(false);
 
     act = addAction(QStringLiteral("clip_in_project_tree"), i18n("Clip in Project Bin"), this, SLOT(slotClipInProjectTree()),
                     QIcon::fromTheme(QStringLiteral("go-jump-definition")), QKeySequence(), clipActionCategory);
     act->setEnabled(false);
     // "C" as data means this action should only be available for clips - not for compositions
     act->setData('C');
 
     act = addAction(QStringLiteral("cut_timeline_clip"), i18n("Cut Clip"), this, SLOT(slotCutTimelineClip()), QIcon::fromTheme(QStringLiteral("edit-cut")),
                     Qt::SHIFT + Qt::Key_R);
 
     act = addAction(QStringLiteral("cut_timeline_all_clips"), i18n("Cut All Clips"), this, SLOT(slotCutTimelineAllClips()), QIcon::fromTheme(QStringLiteral("edit-cut")),
                     Qt::CTRL + Qt::SHIFT + Qt::Key_R);
 
     act = addAction(QStringLiteral("delete_timeline_clip"), i18n("Delete Selected Item"), this, SLOT(slotDeleteItem()),
                     QIcon::fromTheme(QStringLiteral("edit-delete")), Qt::Key_Delete);
 
     QAction *resizeStart = new QAction(QIcon(), i18n("Resize Item Start"), this);
     addAction(QStringLiteral("resize_timeline_clip_start"), resizeStart, Qt::Key_1);
     connect(resizeStart, &QAction::triggered, this, &MainWindow::slotResizeItemStart);
 
     QAction *resizeEnd = new QAction(QIcon(), i18n("Resize Item End"), this);
     addAction(QStringLiteral("resize_timeline_clip_end"), resizeEnd, Qt::Key_2);
     connect(resizeEnd, &QAction::triggered, this, &MainWindow::slotResizeItemEnd);
 
     QAction *pasteEffects = addAction(QStringLiteral("paste_effects"), i18n("Paste Effects"), this, SLOT(slotPasteEffects()),
                                       QIcon::fromTheme(QStringLiteral("edit-paste")), QKeySequence(), clipActionCategory);
     pasteEffects->setEnabled(false);
     // "C" as data means this action should only be available for clips - not for compositions
     pasteEffects->setData('C');
 
     QAction *groupClip = addAction(QStringLiteral("group_clip"), i18n("Group Clips"), this, SLOT(slotGroupClips()),
                                    QIcon::fromTheme(QStringLiteral("object-group")), Qt::CTRL + Qt::Key_G, clipActionCategory);
     // "G" as data means this action should only be available for multiple items selection
     groupClip->setData('G');
     groupClip->setEnabled(false);
 
     QAction *ungroupClip = addAction(QStringLiteral("ungroup_clip"), i18n("Ungroup Clips"), this, SLOT(slotUnGroupClips()),
                                      QIcon::fromTheme(QStringLiteral("object-ungroup")), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_G), clipActionCategory);
     // "U" as data means this action should only be available if selection is a group
     ungroupClip->setData('U');
     ungroupClip->setEnabled(false);
 
     act = clipActionCategory->addAction(KStandardAction::Copy, this, SLOT(slotCopy()));
     act->setEnabled(false);
 
     KStandardAction::paste(this, SLOT(slotPaste()), actionCollection());
 
     /*act = KStandardAction::copy(this, SLOT(slotCopy()), actionCollection());
     clipActionCategory->addAction(KStandardAction::name(KStandardAction::Copy), act);
     act->setEnabled(false);
     act = KStandardAction::paste(this, SLOT(slotPaste()), actionCollection());
     clipActionCategory->addAction(KStandardAction::name(KStandardAction::Paste), act);
     act->setEnabled(false);*/
 
     kdenliveCategoryMap.insert(QStringLiteral("timelineselection"), clipActionCategory);
 
     addAction(QStringLiteral("insert_space"), i18n("Insert Space"), this, SLOT(slotInsertSpace()));
     addAction(QStringLiteral("delete_space"), i18n("Remove Space"), this, SLOT(slotRemoveSpace()));
     addAction(QStringLiteral("delete_space_all_tracks"), i18n("Remove Space In All Tracks"), this, SLOT(slotRemoveAllSpace()));
 
     KActionCategory *timelineActions = new KActionCategory(i18n("Tracks"), actionCollection());
     QAction *insertTrack = new QAction(QIcon(), i18n("Insert Track"), this);
     connect(insertTrack, &QAction::triggered, this, &MainWindow::slotInsertTrack);
     timelineActions->addAction(QStringLiteral("insert_track"), insertTrack);
 
     QAction *masterEffectStack = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-composite")), i18n("Master effects"), this);
     connect(masterEffectStack, &QAction::triggered, [&]() {
         pCore->monitorManager()->activateMonitor(Kdenlive::ProjectMonitor);
         getCurrentTimeline()->controller()->showMasterEffects();
     });
     timelineActions->addAction(QStringLiteral("master_effects"), masterEffectStack);
 
     QAction *deleteTrack = new QAction(QIcon(), i18n("Delete Track"), this);
     connect(deleteTrack, &QAction::triggered, this, &MainWindow::slotDeleteTrack);
     timelineActions->addAction(QStringLiteral("delete_track"), deleteTrack);
     deleteTrack->setData("delete_track");
 
     QAction *showAudio = new QAction(QIcon(), i18n("Show Record Controls"), this);
     connect(showAudio, &QAction::triggered, this, &MainWindow::slotShowTrackRec);
     timelineActions->addAction(QStringLiteral("show_track_record"), showAudio);
     showAudio->setCheckable(true);
     showAudio->setData("show_track_record");
 
     QAction *selectTrack = new QAction(QIcon(), i18n("Select All in Current Track"), this);
     connect(selectTrack, &QAction::triggered, this, &MainWindow::slotSelectTrack);
     timelineActions->addAction(QStringLiteral("select_track"), selectTrack);
 
     QAction *selectAll = KStandardAction::selectAll(this, SLOT(slotSelectAllTracks()), this);
     selectAll->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-select-all")));
     selectAll->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     timelineActions->addAction(QStringLiteral("select_all_tracks"), selectAll);
 
     QAction *unselectAll = KStandardAction::deselect(this, SLOT(slotUnselectAllTracks()), this);
     unselectAll->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-unselect-all")));
     unselectAll->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     timelineActions->addAction(QStringLiteral("unselect_all_tracks"), unselectAll);
 
     kdenliveCategoryMap.insert(QStringLiteral("timeline"), timelineActions);
 
     // Cached data management
     addAction(QStringLiteral("manage_cache"), i18n("Manage Cached Data"), this, SLOT(slotManageCache()),
               QIcon::fromTheme(QStringLiteral("network-server-database")));
 
     QAction *disablePreview = new QAction(i18n("Disable Timeline Preview"), this);
     disablePreview->setCheckable(true);
     addAction(QStringLiteral("disable_preview"), disablePreview);
 
     addAction(QStringLiteral("add_guide"), i18n("Add/Remove Guide"), this, SLOT(slotAddGuide()), QIcon::fromTheme(QStringLiteral("list-add")), Qt::Key_G);
     addAction(QStringLiteral("delete_guide"), i18n("Delete Guide"), this, SLOT(slotDeleteGuide()), QIcon::fromTheme(QStringLiteral("edit-delete")));
     addAction(QStringLiteral("edit_guide"), i18n("Edit Guide"), this, SLOT(slotEditGuide()), QIcon::fromTheme(QStringLiteral("document-properties")));
     addAction(QStringLiteral("delete_all_guides"), i18n("Delete All Guides"), this, SLOT(slotDeleteAllGuides()),
               QIcon::fromTheme(QStringLiteral("edit-delete")));
 
     m_saveAction = KStandardAction::save(pCore->projectManager(), SLOT(saveFile()), actionCollection());
     m_saveAction->setIcon(QIcon::fromTheme(QStringLiteral("document-save")));
 
     QAction *sentToLibrary = addAction(QStringLiteral("send_library"), i18n("Add Timeline Selection to Library"), pCore->library(), SLOT(slotAddToLibrary()),
                                        QIcon::fromTheme(QStringLiteral("bookmark-new")));
     sentToLibrary->setEnabled(false);
 
     pCore->library()->setupActions(QList<QAction *>() << sentToLibrary);
 
     KStandardAction::showMenubar(this, SLOT(showMenuBar(bool)), actionCollection());
 
     act = KStandardAction::quit(this, SLOT(close()), actionCollection());
     // act->setIcon(QIcon::fromTheme(QStringLiteral("application-exit")));
 
     KStandardAction::keyBindings(this, SLOT(slotEditKeys()), actionCollection());
     KStandardAction::preferences(this, SLOT(slotPreferences()), actionCollection());
     KStandardAction::configureNotifications(this, SLOT(configureNotifications()), actionCollection());
     KStandardAction::fullScreen(this, SLOT(slotFullScreen()), this, actionCollection());
 
     QAction *undo = KStandardAction::undo(m_commandStack, SLOT(undo()), actionCollection());
     undo->setEnabled(false);
     connect(m_commandStack, &QUndoGroup::canUndoChanged, undo, &QAction::setEnabled);
     connect(this, &MainWindow::enableUndo, [this, undo] (bool enable) {
         if (enable) {
             enable = m_commandStack->activeStack()->canUndo();
         }
         undo->setEnabled(enable);
     });
 
     QAction *redo = KStandardAction::redo(m_commandStack, SLOT(redo()), actionCollection());
     redo->setEnabled(false);
     connect(m_commandStack, &QUndoGroup::canRedoChanged, redo, &QAction::setEnabled);
     connect(this, &MainWindow::enableUndo, [this, redo] (bool enable) {
         if (enable) {
             enable = m_commandStack->activeStack()->canRedo();
         }
         redo->setEnabled(enable);
     });
 
     QAction *disableEffects = addAction(QStringLiteral("disable_timeline_effects"), i18n("Disable Timeline Effects"), pCore->projectManager(),
                                         SLOT(slotDisableTimelineEffects(bool)), QIcon::fromTheme(QStringLiteral("favorite")));
     disableEffects->setData("disable_timeline_effects");
     disableEffects->setCheckable(true);
     disableEffects->setChecked(false);
 
     addAction(QStringLiteral("switch_track_lock"), i18n("Toggle Track Lock"), pCore->projectManager(), SLOT(slotSwitchTrackLock()), QIcon(),
               Qt::SHIFT + Qt::Key_L);
     addAction(QStringLiteral("switch_all_track_lock"), i18n("Toggle All Track Lock"), pCore->projectManager(), SLOT(slotSwitchAllTrackLock()), QIcon(),
               Qt::CTRL + Qt::SHIFT + Qt::Key_L);
     addAction(QStringLiteral("switch_track_target"), i18n("Toggle Track Target"), pCore->projectManager(), SLOT(slotSwitchTrackTarget()), QIcon(),
               Qt::SHIFT + Qt::Key_T);
     addAction(QStringLiteral("switch_active_target"), i18n("Toggle Track Active"), pCore->projectManager(), SLOT(slotSwitchTrackActive()), QIcon(),
               Qt::Key_A);
     addAction(QStringLiteral("switch_all_targets"), i18n("Toggle All Tracks Active"), pCore->projectManager(), SLOT(slotSwitchAllTrackActive()), QIcon(),
               Qt::SHIFT + Qt::Key_A);
     addAction(QStringLiteral("activate_all_targets"), i18n("Switch All Tracks Active"), pCore->projectManager(), SLOT(slotMakeAllTrackActive()), QIcon(),
               Qt::SHIFT + Qt::ALT + Qt::Key_A);
     addAction(QStringLiteral("add_project_note"), i18n("Add Project Note"), pCore->projectManager(), SLOT(slotAddProjectNote()),
               QIcon::fromTheme(QStringLiteral("bookmark")));
 
     pCore->bin()->setupMenu();
 
     // Setup effects and transitions actions.
     KActionCategory *transitionActions = new KActionCategory(i18n("Transitions"), actionCollection());
     // m_transitions = new QAction*[transitions.count()];
     auto allTransitions = TransitionsRepository::get()->getNames();
     for (const auto &transition : allTransitions) {
         auto *transAction = new QAction(transition.first, this);
         transAction->setData(transition.second);
         transAction->setIconVisibleInMenu(false);
         transitionActions->addAction("transition_" + transition.second, transAction);
     }
 
     // monitor actions
     addAction(QStringLiteral("extract_frame"), i18n("Extract frame..."), pCore->monitorManager(), SLOT(slotExtractCurrentFrame()),
               QIcon::fromTheme(QStringLiteral("insert-image")));
 
     addAction(QStringLiteral("extract_frame_to_project"), i18n("Extract frame to project..."), pCore->monitorManager(),
               SLOT(slotExtractCurrentFrameToProject()), QIcon::fromTheme(QStringLiteral("insert-image")));
 }
 
 void MainWindow::saveOptions()
 {
     KdenliveSettings::self()->save();
 }
 
 bool MainWindow::readOptions()
 {
     KSharedConfigPtr config = KSharedConfig::openConfig();
     pCore->projectManager()->recentFilesAction()->loadEntries(KConfigGroup(config, "Recent Files"));
 
     if (KdenliveSettings::defaultprojectfolder().isEmpty()) {
         QDir dir(QStandardPaths::writableLocation(QStandardPaths::MoviesLocation));
         dir.mkpath(QStringLiteral("."));
         KdenliveSettings::setDefaultprojectfolder(dir.absolutePath());
     }
     if (KdenliveSettings::trackheight() == 0) {
         QFontMetrics metrics(font());
         int trackHeight = 2 * metrics.height();
         QStyle *style = qApp->style();
         trackHeight += style->pixelMetric(QStyle::PM_ToolBarIconSize) + 2 * style->pixelMetric(QStyle::PM_ToolBarItemMargin) +
                        style->pixelMetric(QStyle::PM_ToolBarItemSpacing) + 2;
         KdenliveSettings::setTrackheight(trackHeight == 0 ? 50 : trackHeight);
     }
     bool firstRun = false;
     KConfigGroup initialGroup(config, "version");
     if (!initialGroup.exists() || KdenliveSettings::sdlAudioBackend().isEmpty()) {
         // First run, check if user is on a KDE Desktop
         firstRun = true;
         //Define default video location for first run
         KRecentDirs::add(QStringLiteral(":KdenliveClipFolder"), QStandardPaths::writableLocation(QStandardPaths::MoviesLocation));
 
         // this is our first run, show Wizard
         QPointer<Wizard> w = new Wizard(true, false);
         if (w->exec() == QDialog::Accepted && w->isOk()) {
             w->adjustSettings();
             delete w;
         } else {
             delete w;
             ::exit(1);
         }
     } else if (!KdenliveSettings::ffmpegpath().isEmpty() && !QFile::exists(KdenliveSettings::ffmpegpath())) {
         // Invalid entry for FFmpeg, check system
         QPointer<Wizard> w = new Wizard(true, config->name().contains(QLatin1String("appimage")));
         if (w->exec() == QDialog::Accepted && w->isOk()) {
             w->adjustSettings();
         }
         delete w;
     }
     initialGroup.writeEntry("version", version);
     return firstRun;
 }
 
 void MainWindow::slotRunWizard()
 {
     QPointer<Wizard> w = new Wizard(false, false, this);
     if (w->exec() == QDialog::Accepted && w->isOk()) {
         w->adjustSettings();
     }
     delete w;
 }
 
 void MainWindow::slotRefreshProfiles()
 {
     KdenliveSettingsDialog *d = static_cast<KdenliveSettingsDialog *>(KConfigDialog::exists(QStringLiteral("settings")));
     if (d) {
         d->checkProfile();
     }
 }
 
 void MainWindow::slotEditProjectSettings()
 {
     KdenliveDoc *project = pCore->currentDoc();
     QPoint p = getMainTimeline()->getTracksCount();
 
     ProjectSettings *w = new ProjectSettings(project, project->metadata(), getMainTimeline()->controller()->extractCompositionLumas(), p.x(), p.y(),
                                              project->projectTempFolder(), true, !project->isModified(), this);
     connect(w, &ProjectSettings::disableProxies, this, &MainWindow::slotDisableProxies);
     // connect(w, SIGNAL(disablePreview()), pCore->projectManager()->currentTimeline(), SLOT(invalidateRange()));
     connect(w, &ProjectSettings::refreshProfiles, this, &MainWindow::slotRefreshProfiles);
 
     if (w->exec() == QDialog::Accepted) {
         QString profile = w->selectedProfile();
         // project->setProjectFolder(w->selectedFolder());
         bool modified = false;
         if (m_renderWidget) {
             m_renderWidget->updateDocumentPath();
         }
         if (KdenliveSettings::videothumbnails() != w->enableVideoThumbs()) {
             slotSwitchVideoThumbs();
         }
         if (KdenliveSettings::audiothumbnails() != w->enableAudioThumbs()) {
             slotSwitchAudioThumbs();
         }
         if (project->getDocumentProperty(QStringLiteral("previewparameters")) != w->proxyParams() ||
             project->getDocumentProperty(QStringLiteral("previewextension")) != w->proxyExtension()) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("previewparameters"), w->previewParams());
             project->setDocumentProperty(QStringLiteral("previewextension"), w->previewExtension());
             slotClearPreviewRender(false);
         }
         if (project->getDocumentProperty(QStringLiteral("proxyparams")) != w->proxyParams() ||
             project->getDocumentProperty(QStringLiteral("proxyextension")) != w->proxyExtension()) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("proxyparams"), w->proxyParams());
             project->setDocumentProperty(QStringLiteral("proxyextension"), w->proxyExtension());
             if (pCore->projectItemModel()->clipsCount() > 0 &&
                 KMessageBox::questionYesNo(this, i18n("You have changed the proxy parameters. Do you want to recreate all proxy clips for this project?")) ==
                     KMessageBox::Yes) {
                 pCore->bin()->rebuildProxies();
             }
         }
 
         if (project->getDocumentProperty(QStringLiteral("externalproxyparams")) != w->externalProxyParams()) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("externalproxyparams"), w->externalProxyParams());
             if (pCore->projectItemModel()->clipsCount() > 0 &&
                 KMessageBox::questionYesNo(this, i18n("You have changed the proxy parameters. Do you want to recreate all proxy clips for this project?")) ==
                     KMessageBox::Yes) {
                 pCore->bin()->rebuildProxies();
             }
         }
 
         if (project->getDocumentProperty(QStringLiteral("generateproxy")) != QString::number((int)w->generateProxy())) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("generateproxy"), QString::number((int)w->generateProxy()));
         }
         if (project->getDocumentProperty(QStringLiteral("proxyminsize")) != QString::number(w->proxyMinSize())) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("proxyminsize"), QString::number(w->proxyMinSize()));
         }
         if (project->getDocumentProperty(QStringLiteral("generateimageproxy")) != QString::number((int)w->generateImageProxy())) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("generateimageproxy"), QString::number((int)w->generateImageProxy()));
         }
         if (project->getDocumentProperty(QStringLiteral("proxyimageminsize")) != QString::number(w->proxyImageMinSize())) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("proxyimageminsize"), QString::number(w->proxyImageMinSize()));
         }
         if (project->getDocumentProperty(QStringLiteral("proxyimagesize")) != QString::number(w->proxyImageSize())) {
             modified = true;
             project->setDocumentProperty(QStringLiteral("proxyimagesize"), QString::number(w->proxyImageSize()));
         }
         if (QString::number((int)w->useProxy()) != project->getDocumentProperty(QStringLiteral("enableproxy"))) {
             project->setDocumentProperty(QStringLiteral("enableproxy"), QString::number((int)w->useProxy()));
             modified = true;
             slotUpdateProxySettings();
         }
         if (QString::number((int)w->useExternalProxy()) != project->getDocumentProperty(QStringLiteral("enableexternalproxy"))) {
             project->setDocumentProperty(QStringLiteral("enableexternalproxy"), QString::number((int)w->useExternalProxy()));
             modified = true;
         }
         if (w->metadata() != project->metadata()) {
             project->setMetadata(w->metadata());
         }
         QString newProjectFolder = w->storageFolder();
         if (newProjectFolder.isEmpty()) {
             newProjectFolder = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
         }
         if (newProjectFolder != project->projectTempFolder()) {
             KMessageBox::ButtonCode answer;
             // Project folder changed:
             if (project->isModified()) {
                 answer = KMessageBox::warningContinueCancel(this, i18n("The current project has not been saved. This will first save the project, then move "
                                                                        "all temporary files from <b>%1</b> to <b>%2</b>, and the project file will be reloaded",
                                                                        project->projectTempFolder(), newProjectFolder));
                 if (answer == KMessageBox::Continue) {
                     pCore->projectManager()->saveFile();
                 }
             } else {
                 answer = KMessageBox::warningContinueCancel(
                     this, i18n("This will move all temporary files from <b>%1</b> to <b>%2</b>, the project file will then be reloaded",
                                project->projectTempFolder(), newProjectFolder));
             }
             if (answer == KMessageBox::Continue) {
                 // Proceed with move
                 QString documentId = QDir::cleanPath(project->getDocumentProperty(QStringLiteral("documentid")));
                 bool ok;
                 documentId.toLongLong(&ok, 10);
                 if (!ok || documentId.isEmpty()) {
                     KMessageBox::sorry(this, i18n("Cannot perform operation, invalid document id: %1", documentId));
                 } else {
                     QDir newDir(newProjectFolder);
                     QDir oldDir(project->projectTempFolder());
                     if (newDir.exists(documentId)) {
                         KMessageBox::sorry(this, i18n("Cannot perform operation, target directory already exists: %1", newDir.absoluteFilePath(documentId)));
                     } else {
                         // Proceed with the move
                         pCore->projectManager()->moveProjectData(oldDir.absoluteFilePath(documentId), newDir.absolutePath());
                     }
                 }
             }
         }
         if (pCore->getCurrentProfile()->path() != profile || project->profileChanged(profile)) {
             if (!qFuzzyCompare(pCore->getCurrentProfile()->fps() - ProfileRepository::get()->getProfile(profile)->fps(), 0.)) {
                 // Fps was changed, we save the project to an xml file with updated profile and reload project
                 // Check if blank project
                 if (project->url().fileName().isEmpty() && !project->isModified()) {
                     // Trying to switch project profile from an empty project
                     pCore->setCurrentProfile(profile);
                     pCore->projectManager()->newFile(profile, false);
                     return;
                 }
                 pCore->projectManager()->saveWithUpdatedProfile(profile);
             } else {
                 pCore->setCurrentProfile(profile);
                 pCore->projectManager()->slotResetProfiles();
                 slotUpdateDocumentState(true);
             }
         } else if (modified) {
             project->setModified();
         }
     }
     delete w;
 }
 
 void MainWindow::slotDisableProxies()
 {
     pCore->currentDoc()->setDocumentProperty(QStringLiteral("enableproxy"), QString::number((int)false));
     pCore->currentDoc()->setModified();
     slotUpdateProxySettings();
 }
 
 void MainWindow::slotStopRenderProject()
 {
     if (m_renderWidget) {
         m_renderWidget->slotAbortCurrentJob();
     }
 }
 
 void MainWindow::slotRenderProject()
 {
     KdenliveDoc *project = pCore->currentDoc();
 
     if (!m_renderWidget) {
         QString projectfolder = project ? project->projectDataFolder() + QDir::separator() : KdenliveSettings::defaultprojectfolder();
         if (project) {
             m_renderWidget = new RenderWidget(project->useProxy(), this);
             connect(m_renderWidget, &RenderWidget::shutdown, this, &MainWindow::slotShutdown);
             connect(m_renderWidget, &RenderWidget::selectedRenderProfile, this, &MainWindow::slotSetDocumentRenderProfile);
             connect(m_renderWidget, &RenderWidget::abortProcess, this, &MainWindow::abortRenderJob);
             connect(m_renderWidget, &RenderWidget::openDvdWizard, this, &MainWindow::slotDvdWizard);
             connect(this, &MainWindow::updateRenderWidgetProfile, m_renderWidget, &RenderWidget::adjustViewToProfile);
             m_renderWidget->setGuides(project->getGuideModel());
             m_renderWidget->updateDocumentPath();
             m_renderWidget->setRenderProfile(project->getRenderProperties());
         }
         if (m_compositeAction->currentAction()) {
             m_renderWidget->errorMessage(RenderWidget::CompositeError, m_compositeAction->currentAction()->data().toInt() == 1
                                                                            ? i18n("Rendering using low quality track compositing")
                                                                            : QString());
         }
     }
     slotCheckRenderStatus();
     m_renderWidget->show();
     // m_renderWidget->showNormal();
 
     // What are the following lines supposed to do?
     // m_renderWidget->enableAudio(false);
     // m_renderWidget->export_audio;
 }
 
 void MainWindow::slotCheckRenderStatus()
 {
     // Make sure there are no missing clips
     // TODO
     /*if (m_renderWidget)
         m_renderWidget->missingClips(pCore->bin()->hasMissingClips());*/
 }
 
 void MainWindow::setRenderingProgress(const QString &url, int progress)
 {
     emit setRenderProgress(progress);
     if (m_renderWidget) {
         m_renderWidget->setRenderJob(url, progress);
     }
 }
 
 void MainWindow::setRenderingFinished(const QString &url, int status, const QString &error)
 {
     emit setRenderProgress(100);
     if (m_renderWidget) {
         m_renderWidget->setRenderStatus(url, status, error);
     }
 }
 
 void MainWindow::addProjectClip(const QString &url)
 {
     if (pCore->currentDoc()) {
         QStringList ids = pCore->projectItemModel()->getClipByUrl(QFileInfo(url));
         if (!ids.isEmpty()) {
             // Clip is already in project bin, abort
             return;
         }
 
         ClipCreator::createClipFromFile(url, pCore->projectItemModel()->getRootFolder()->clipId(), pCore->projectItemModel());
     }
 }
 
 void MainWindow::addTimelineClip(const QString &url)
 {
     if (pCore->currentDoc()) {
         QStringList ids = pCore->projectItemModel()->getClipByUrl(QFileInfo(url));
         if (!ids.isEmpty()) {
             pCore->selectBinClip(ids.constFirst());
             slotInsertClipInsert();
         }
     }
 }
 
 void MainWindow::scriptRender(const QString &url)
 {
     slotRenderProject();
     m_renderWidget->slotPrepareExport(true, url);
 }
 
 void MainWindow::exitApp()
 {
     QApplication::exit(0);
 }
 
 void MainWindow::slotCleanProject()
 {
     if (KMessageBox::warningContinueCancel(this, i18n("This will remove all unused clips from your project."), i18n("Clean up project")) ==
         KMessageBox::Cancel) {
         return;
     }
     pCore->bin()->cleanup();
 }
 
 void MainWindow::slotUpdateMousePosition(int pos)
 {
     if (pCore->currentDoc()) {
         switch (m_timeFormatButton->currentItem()) {
         case 0:
             m_timeFormatButton->setText(pCore->currentDoc()->timecode().getTimecodeFromFrames(pos) + QStringLiteral(" / ") +
                                         pCore->currentDoc()->timecode().getTimecodeFromFrames(getMainTimeline()->controller()->duration()));
             break;
         default:
             m_timeFormatButton->setText(
                 QStringLiteral("%1 / %2").arg(pos, 6, 10, QLatin1Char('0')).arg(getMainTimeline()->controller()->duration(), 6, 10, QLatin1Char('0')));
         }
     }
 }
 
 void MainWindow::slotUpdateProjectDuration(int pos)
 {
     Q_UNUSED(pos)
     if (pCore->currentDoc()) {
         slotUpdateMousePosition(getMainTimeline()->controller()->getMousePos());
     }
 }
 
 void MainWindow::slotUpdateDocumentState(bool modified)
 {
     setWindowTitle(pCore->currentDoc()->description());
     setWindowModified(modified);
     m_saveAction->setEnabled(modified);
 }
 
 void MainWindow::connectDocument()
 {
     KdenliveDoc *project = pCore->currentDoc();
     connect(project, &KdenliveDoc::startAutoSave, pCore->projectManager(), &ProjectManager::slotStartAutoSave);
     connect(project, &KdenliveDoc::reloadEffects, this, &MainWindow::slotReloadEffects);
     KdenliveSettings::setProject_fps(pCore->getCurrentFps());
     m_projectMonitor->slotLoadClipZone(project->zone());
     connect(m_projectMonitor, &Monitor::multitrackView, getMainTimeline()->controller(), &TimelineController::slotMultitrackView, Qt::UniqueConnection);
     connect(m_projectMonitor, &Monitor::activateTrack, getMainTimeline()->controller(), &TimelineController::activateTrackAndSelect, Qt::UniqueConnection);
     connect(getMainTimeline()->controller(), &TimelineController::timelineClipSelected, pCore->library(), &LibraryWidget::enableAddSelection,
             Qt::UniqueConnection);
     connect(pCore->library(), &LibraryWidget::saveTimelineSelection, getMainTimeline()->controller(), &TimelineController::saveTimelineSelection,
             Qt::UniqueConnection);
     connect(pCore->monitorManager(), &MonitorManager::frameDisplayed, [&](const SharedFrame &frame) {
         pCore->mixer()->updateLevels(frame.get_position());
         //QMetaObject::invokeMethod(this, "setAudioValues", Qt::QueuedConnection, Q_ARG(const QVector<int> &, levels));
     });
     connect(pCore->mixer(), &MixerManager::purgeCache, m_projectMonitor, &Monitor::purgeCache);
 
     // TODO REFAC: reconnect to new timeline
     /*
     Timeline *trackView = pCore->projectManager()->currentTimeline();
     connect(trackView, &Timeline::configTrack, this, &MainWindow::slotConfigTrack);
     connect(trackView, &Timeline::updateTracksInfo, this, &MainWindow::slotUpdateTrackInfo);
     connect(trackView, &Timeline::mousePosition, this, &MainWindow::slotUpdateMousePosition);
     connect(pCore->producerQueue(), &ProducerQueue::infoProcessingFinished, trackView->projectView(), &CustomTrackView::slotInfoProcessingFinished,
     Qt::DirectConnection);
 
     connect(trackView->projectView(), &CustomTrackView::importKeyframes, this, &MainWindow::slotProcessImportKeyframes);
     connect(trackView->projectView(), &CustomTrackView::updateTrimMode, this, &MainWindow::setTrimMode);
     connect(m_projectMonitor, SIGNAL(renderPosition(int)), trackView, SLOT(moveCursorPos(int)));
     connect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), trackView, SLOT(slotSetZone(QPoint)));
 
     connect(trackView->projectView(), &CustomTrackView::guidesUpdated, this, &MainWindow::slotGuidesUpdated);
     connect(trackView->projectView(), &CustomTrackView::loadMonitorScene, m_projectMonitor, &Monitor::slotShowEffectScene);
     connect(trackView->projectView(), &CustomTrackView::setQmlProperty, m_projectMonitor, &Monitor::setQmlProperty);
     connect(m_projectMonitor, SIGNAL(acceptRipple(bool)), trackView->projectView(), SLOT(slotAcceptRipple(bool)));
     connect(m_projectMonitor, SIGNAL(switchTrimMode(int)), trackView->projectView(), SLOT(switchTrimMode(int)));
     connect(project, &KdenliveDoc::saveTimelinePreview, trackView, &Timeline::slotSaveTimelinePreview);
 
     connect(trackView, SIGNAL(showTrackEffects(int, TrackInfo)), this, SLOT(slotTrackSelected(int, TrackInfo)));
 
     connect(trackView->projectView(), &CustomTrackView::clipItemSelected, this, &MainWindow::slotTimelineClipSelected, Qt::DirectConnection);
     connect(trackView->projectView(), &CustomTrackView::setActiveKeyframe, m_effectStack, &EffectStackView2::setActiveKeyframe);
     connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition *, int, QPoint, bool)), m_effectStack, SLOT(slotTransitionItemSelected(Transition
     *, int, QPoint, bool)), Qt::DirectConnection);
 
     connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition *, int, QPoint, bool)), this, SLOT(slotActivateTransitionView(Transition *)));
 
     connect(trackView->projectView(), &CustomTrackView::zoomIn, this, &MainWindow::slotZoomIn);
     connect(trackView->projectView(), &CustomTrackView::zoomOut, this, &MainWindow::slotZoomOut);
     connect(trackView, SIGNAL(setZoom(int)), this, SLOT(slotSetZoom(int)));
 
     connect(trackView, SIGNAL(displayMessage(QString, MessageType)), m_messageLabel, SLOT(setMessage(QString, MessageType)));
     connect(trackView->projectView(), SIGNAL(displayMessage(QString, MessageType)), m_messageLabel, SLOT(setMessage(QString, MessageType)));
     connect(pCore->bin(), &Bin::clipNameChanged, trackView->projectView(), &CustomTrackView::clipNameChanged);
 
     connect(trackView->projectView(), SIGNAL(showClipFrame(QString, int)), pCore->bin(), SLOT(selectClipById(QString, int)));
     connect(trackView->projectView(), SIGNAL(playMonitor()), m_projectMonitor, SLOT(slotPlay()));
     connect(trackView->projectView(), &CustomTrackView::pauseMonitor, m_projectMonitor, &Monitor::pause, Qt::DirectConnection);
 
     connect(m_projectMonitor, &Monitor::addEffect, trackView->projectView(), &CustomTrackView::slotAddEffectToCurrentItem);
 
     connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition *, int, QPoint, bool)), m_projectMonitor, SLOT(slotSetSelectedClip(Transition
     *)));
 
     connect(pCore->bin(), SIGNAL(gotFilterJobResults(QString, int, int, stringMap, stringMap)), trackView->projectView(), SLOT(slotGotFilterJobResults(QString,
     int, int, stringMap, stringMap)));
 
     //TODO
     //connect(m_projectList, SIGNAL(addMarkers(QString,QList<CommentedTime>)), trackView->projectView(), SLOT(slotAddClipMarker(QString,QList<CommentedTime>)));
 
     // Effect stack signals
     connect(m_effectStack, &EffectStackView2::updateEffect, trackView->projectView(), &CustomTrackView::slotUpdateClipEffect);
     connect(m_effectStack, &EffectStackView2::updateClipRegion, trackView->projectView(), &CustomTrackView::slotUpdateClipRegion);
     connect(m_effectStack, SIGNAL(removeEffect(ClipItem *, int, QDomElement)), trackView->projectView(), SLOT(slotDeleteEffect(ClipItem *, int, QDomElement)));
     connect(m_effectStack, SIGNAL(removeEffectGroup(ClipItem *, int, QDomDocument)), trackView->projectView(), SLOT(slotDeleteEffectGroup(ClipItem *, int,
     QDomDocument)));
 
     connect(m_effectStack, SIGNAL(addEffect(ClipItem *, QDomElement, int)), trackView->projectView(), SLOT(slotAddEffect(ClipItem *, QDomElement, int)));
     connect(m_effectStack, SIGNAL(changeEffectState(ClipItem *, int, QList<int>, bool)), trackView->projectView(), SLOT(slotChangeEffectState(ClipItem *, int,
     QList<int>, bool)));
     connect(m_effectStack, SIGNAL(changeEffectPosition(ClipItem *, int, QList<int>, int)), trackView->projectView(), SLOT(slotChangeEffectPosition(ClipItem *,
     int, QList<int>, int)));
 
     connect(m_effectStack, &EffectStackView2::refreshEffectStack, trackView->projectView(), &CustomTrackView::slotRefreshEffects);
     connect(m_effectStack, &EffectStackView2::seekTimeline, trackView->projectView(), &CustomTrackView::seekCursorPos);
     connect(m_effectStack, SIGNAL(importClipKeyframes(GraphicsRectItem, ItemInfo, QDomElement, QMap<QString, QString>)), trackView->projectView(),
     SLOT(slotImportClipKeyframes(GraphicsRectItem, ItemInfo, QDomElement, QMap<QString, QString>)));
 
     // Transition config signals
     connect(m_effectStack->transitionConfig(), SIGNAL(transitionUpdated(Transition *, QDomElement)), trackView->projectView(),
     SLOT(slotTransitionUpdated(Transition *, QDomElement)));
     connect(m_effectStack->transitionConfig(), &TransitionSettings::seekTimeline, trackView->projectView(), &CustomTrackView::seekCursorPos);
 
     connect(trackView->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(slotActivateMonitor()), Qt::DirectConnection);
     connect(project, &KdenliveDoc::updateFps, this,
             [this](double changed) {
         if (changed == 0.0) {
             slotUpdateProfile(false);
         } else {
             slotUpdateProfile(true);
         }
     }, Qt::DirectConnection);
     connect(trackView, &Timeline::zoneMoved, this, &MainWindow::slotZoneMoved);
     trackView->projectView()->setContextMenu(m_timelineContextMenu, m_timelineClipActions, m_timelineContextTransitionMenu, m_clipTypeGroup,
     static_cast<QMenu *>(factory()->container(QStringLiteral("marker_menu"), this)));
     */
 
     getMainTimeline()->controller()->clipActions = kdenliveCategoryMap.value(QStringLiteral("timelineselection"))->actions();
     connect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), project, SLOT(setModified()));
     connect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), project, SLOT(setModified()));
     connect(project, &KdenliveDoc::docModified, this, &MainWindow::slotUpdateDocumentState);
 
     if (m_renderWidget) {
         slotCheckRenderStatus();
         m_renderWidget->setGuides(pCore->currentDoc()->getGuideModel());
         m_renderWidget->updateDocumentPath();
         m_renderWidget->setRenderProfile(project->getRenderProperties());
     }
     m_zoomSlider->setValue(project->zoom().x());
     m_commandStack->setActiveStack(project->commandStack().get());
 
     setWindowTitle(project->description());
     setWindowModified(project->isModified());
     m_saveAction->setEnabled(project->isModified());
     m_normalEditTool->setChecked(true);
     connect(m_projectMonitor, &Monitor::durationChanged, this, &MainWindow::slotUpdateProjectDuration);
     connect(m_effectList2, &EffectListWidget::reloadFavorites, getMainTimeline(), &TimelineWidget::updateEffectFavorites);
     connect(m_transitionList2, &TransitionListWidget::reloadFavorites, getMainTimeline(), &TimelineWidget::updateTransitionFavorites);
     connect(pCore->bin(), &Bin::processDragEnd, getMainTimeline(), &TimelineWidget::endDrag);
 
     // TODO REFAC: fix
     // trackView->updateProfile(1.0);
     // Init document zone
     // m_projectMonitor->slotZoneMoved(trackView->inPoint(), trackView->outPoint());
     // Update the mouse position display so it will display in DF/NDF format by default based on the project setting.
     // slotUpdateMousePosition(0);
 
     // Update guides info in render widget
     // slotGuidesUpdated();
 
     // set tool to select tool
     setTrimMode(QString());
 
     m_buttonSelectTool->setChecked(true);
     connect(m_projectMonitorDock, &QDockWidget::visibilityChanged, m_projectMonitor, &Monitor::slotRefreshMonitor, Qt::UniqueConnection);
     connect(m_clipMonitorDock, &QDockWidget::visibilityChanged, m_clipMonitor, &Monitor::slotRefreshMonitor, Qt::UniqueConnection);
     getMainTimeline()->focusTimeline();
 }
 
 void MainWindow::slotGuidesUpdated()
 {
     if (m_renderWidget) {
         m_renderWidget->setGuides(pCore->currentDoc()->getGuideModel());
     }
 }
 
 void MainWindow::slotEditKeys()
 {
     KShortcutsDialog dialog(KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsAllowed, this);
     // Find the combobox inside KShortcutsDialog for choosing keyboard scheme
     QComboBox *schemesList = nullptr;
     foreach (QLabel *label, dialog.findChildren<QLabel *>()) {
         if (label->text() == i18n("Current scheme:")) {
             schemesList = qobject_cast<QComboBox *>(label->buddy());
             break;
         }
     }
     // If scheme choosing combobox was found, find the "More Actions" button in the same
     // dialog that provides a dropdown menu with additional actions, and add
     // "Download New Keyboard Schemes..." button into that menu
     if (schemesList) {
         foreach (QPushButton *button, dialog.findChildren<QPushButton *>()) {
             if (button->text() == i18n("More Actions")) {
                 QMenu *moreActionsMenu = button->menu();
                 moreActionsMenu->addAction(i18n("Download New Keyboard Schemes..."), this, [this, schemesList] { slotGetNewKeyboardStuff(schemesList); });
                 break;
             }
         }
     } else {
         qWarning() << "Could not get list of schemes. Downloading new schemes is not available.";
     }
     dialog.addCollection(actionCollection(), i18nc("general keyboard shortcuts", "General"));
     dialog.configure();
 }
 
 void MainWindow::slotPreferences(int page, int option)
 {
     /*
      * An instance of your dialog could be already created and could be
      * cached, in which case you want to display the cached dialog
      * instead of creating another one
      */
     if (KConfigDialog::showDialog(QStringLiteral("settings"))) {
         KdenliveSettingsDialog *d = static_cast<KdenliveSettingsDialog *>(KConfigDialog::exists(QStringLiteral("settings")));
         if (page != -1) {
             d->showPage(page, option);
         }
         return;
     }
 
     // KConfigDialog didn't find an instance of this dialog, so lets
     // create it :
 
     // Get the mappable actions in localized form
     QMap<QString, QString> actions;
     KActionCollection *collection = actionCollection();
     QRegExp ampEx("&{1,1}");
     for (const QString &action_name : m_actionNames) {
         QString action_text = collection->action(action_name)->text();
         action_text.remove(ampEx);
         actions[action_text] = action_name;
     }
 
     auto *dialog = new KdenliveSettingsDialog(actions, m_gpuAllowed, this);
     connect(dialog, &KConfigDialog::settingsChanged, this, &MainWindow::updateConfiguration);
     connect(dialog, &KConfigDialog::settingsChanged, this, &MainWindow::configurationChanged);
     connect(dialog, &KdenliveSettingsDialog::doResetProfile, pCore->projectManager(), &ProjectManager::slotResetProfiles);
     connect(dialog, &KdenliveSettingsDialog::doResetConsumer, [this] (bool fullReset) {
         m_scaleGroup->setEnabled(!KdenliveSettings::external_display());
         pCore->projectManager()->slotResetConsumers(fullReset);
     });
     connect(dialog, &KdenliveSettingsDialog::checkTabPosition, this, &MainWindow::slotCheckTabPosition);
     connect(dialog, &KdenliveSettingsDialog::restartKdenlive, this, &MainWindow::slotRestart);
     connect(dialog, &KdenliveSettingsDialog::updateLibraryFolder, pCore.get(), &Core::updateLibraryPath);
     connect(dialog, &KdenliveSettingsDialog::audioThumbFormatChanged, m_timelineTabs, &TimelineTabs::audioThumbFormatChanged);
     connect(dialog, &KdenliveSettingsDialog::resetView, this, &MainWindow::resetTimelineTracks);
     connect(dialog, &KdenliveSettingsDialog::updateMonitorBg, [&]() {
         pCore->monitorManager()->updateBgColor();
     });
 
     dialog->show();
     if (page != -1) {
         dialog->showPage(page, option);
     }
 }
 
 void MainWindow::slotCheckTabPosition()
 {
     int pos = tabPosition(Qt::LeftDockWidgetArea);
     if (KdenliveSettings::tabposition() != pos) {
         setTabPosition(Qt::AllDockWidgetAreas, (QTabWidget::TabPosition)KdenliveSettings::tabposition());
     }
 }
 
 void MainWindow::slotRestart(bool clean)
 {
     if (clean) {
         if (KMessageBox::questionYesNo(this, i18n("This will delete Kdenlive's configuration file and restart the application. Do you want to proceed?")) != KMessageBox::Yes) {
             return;
         }
     }
     m_exitCode = clean ? EXIT_CLEAN_RESTART : EXIT_RESTART;
     QApplication::closeAllWindows();
 }
 
 void MainWindow::closeEvent(QCloseEvent *event)
 {
     KXmlGuiWindow::closeEvent(event);
     if (event->isAccepted()) {
         QApplication::exit(m_exitCode);
         return;
     }
 }
 
 void MainWindow::updateConfiguration()
 {
     // TODO: we should apply settings to all projects, not only the current one
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
     m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
     m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
     slotSwitchAutomaticTransition();
 
     // Update list of transcoding profiles
     buildDynamicActions();
     loadClipActions();
 }
 
 void MainWindow::slotSwitchVideoThumbs()
 {
     KdenliveSettings::setVideothumbnails(!KdenliveSettings::videothumbnails());
     m_timelineTabs->showThumbnailsChanged();
     m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
 }
 
 void MainWindow::slotSwitchAudioThumbs()
 {
     KdenliveSettings::setAudiothumbnails(!KdenliveSettings::audiothumbnails());
     m_timelineTabs->showAudioThumbnailsChanged();
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
 }
 
 void MainWindow::slotSwitchMarkersComments()
 {
     KdenliveSettings::setShowmarkers(!KdenliveSettings::showmarkers());
     getMainTimeline()->controller()->showMarkersChanged();
     m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
 }
 
 void MainWindow::slotSwitchSnap()
 {
     KdenliveSettings::setSnaptopoints(!KdenliveSettings::snaptopoints());
     m_buttonSnap->setChecked(KdenliveSettings::snaptopoints());
     getMainTimeline()->controller()->snapChanged();
 }
 
 void MainWindow::slotSwitchAutomaticTransition()
 {
     KdenliveSettings::setAutomatictransitions(!KdenliveSettings::automatictransitions());
     m_buttonAutomaticTransition->setChecked(KdenliveSettings::automatictransitions());
 }
 
 void MainWindow::slotDeleteItem()
 {
     if ((QApplication::focusWidget() != nullptr) && (QApplication::focusWidget()->parentWidget() != nullptr) &&
         QApplication::focusWidget()->parentWidget() == pCore->bin()) {
         pCore->bin()->slotDeleteClip();
 
     } else {
         QWidget *widget = QApplication::focusWidget();
         while ((widget != nullptr) && widget != this) {
             if (widget == m_effectStackDock) {
                 m_assetPanel->deleteCurrentEffect();
                 return;
             }
             widget = widget->parentWidget();
         }
 
         // effect stack has no focus
         getMainTimeline()->controller()->deleteSelectedClips();
     }
 }
 
 void MainWindow::slotAddClipMarker()
 {
     std::shared_ptr<ProjectClip> clip(nullptr);
     GenTime pos;
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->addMarker();
         return;
     } else {
         clip = m_clipMonitor->currentController();
         pos = GenTime(m_clipMonitor->position(), pCore->getCurrentFps());
     }
     if (!clip) {
         m_messageLabel->setMessage(i18n("Cannot find clip to add marker"), ErrorMessage);
         return;
     }
     QString id = clip->AbstractProjectItem::clipId();
     clip->getMarkerModel()->editMarkerGui(pos, this, true, clip.get());
 }
 
 void MainWindow::slotDeleteClipMarker(bool allowGuideDeletion)
 {
     std::shared_ptr<ProjectClip> clip(nullptr);
     GenTime pos;
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->deleteMarker();
         return;
     } else {
         clip = m_clipMonitor->currentController();
         pos = GenTime(m_clipMonitor->position(), pCore->getCurrentFps());
     }
     if (!clip) {
         m_messageLabel->setMessage(i18n("Cannot find clip to remove marker"), ErrorMessage);
         return;
     }
 
     QString id = clip->AbstractProjectItem::clipId();
     bool markerFound = false;
     CommentedTime marker = clip->getMarkerModel()->getMarker(pos, &markerFound);
     if (!markerFound) {
         if (allowGuideDeletion && m_projectMonitor->isActive()) {
             slotDeleteGuide();
         } else {
             m_messageLabel->setMessage(i18n("No marker found at cursor time"), ErrorMessage);
         }
         return;
     }
     clip->getMarkerModel()->removeMarker(pos);
 }
 
 void MainWindow::slotDeleteAllClipMarkers()
 {
     std::shared_ptr<ProjectClip> clip(nullptr);
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->deleteAllMarkers();
         return;
     } else {
         clip = m_clipMonitor->currentController();
     }
     if (!clip) {
         m_messageLabel->setMessage(i18n("Cannot find clip to remove marker"), ErrorMessage);
         return;
     }
     bool ok = clip->getMarkerModel()->removeAllMarkers();
     if (!ok) {
         m_messageLabel->setMessage(i18n("An error occurred while deleting markers"), ErrorMessage);
         return;
     }
 }
 
 void MainWindow::slotEditClipMarker()
 {
     std::shared_ptr<ProjectClip> clip(nullptr);
     GenTime pos;
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->editMarker();
         return;
     } else {
         clip = m_clipMonitor->currentController();
         pos = GenTime(m_clipMonitor->position(), pCore->getCurrentFps());
     }
     if (!clip) {
         m_messageLabel->setMessage(i18n("Cannot find clip to edit marker"), ErrorMessage);
         return;
     }
 
     QString id = clip->AbstractProjectItem::clipId();
     bool markerFound = false;
     CommentedTime oldMarker = clip->getMarkerModel()->getMarker(pos, &markerFound);
     if (!markerFound) {
         m_messageLabel->setMessage(i18n("No marker found at cursor time"), ErrorMessage);
         return;
     }
 
     clip->getMarkerModel()->editMarkerGui(pos, this, false, clip.get());
 }
 
 void MainWindow::slotAddMarkerGuideQuickly()
 {
     if (!getMainTimeline() || !pCore->currentDoc()) {
         return;
     }
 
     if (m_clipMonitor->isActive()) {
         std::shared_ptr<ProjectClip> clip(m_clipMonitor->currentController());
         GenTime pos(m_clipMonitor->position(), pCore->getCurrentFps());
 
         if (!clip) {
             m_messageLabel->setMessage(i18n("Cannot find clip to add marker"), ErrorMessage);
             return;
         }
         CommentedTime marker(pos, pCore->currentDoc()->timecode().getDisplayTimecode(pos, false), KdenliveSettings::default_marker_type());
         clip->getMarkerModel()->addMarker(marker.time(), marker.comment(), marker.markerType());
     } else {
         int selectedClip = getMainTimeline()->controller()->getMainSelectedItem();
         if (selectedClip == -1) {
             // Add timeline guide
             getMainTimeline()->controller()->switchGuide();
         } else {
             // Add marker to main clip
             getMainTimeline()->controller()->addQuickMarker(selectedClip);
         }
     }
 }
 
 void MainWindow::slotAddGuide()
 {
     getMainTimeline()->controller()->switchGuide();
 }
 
 void MainWindow::slotInsertSpace()
 {
     getMainTimeline()->controller()->insertSpace();
 }
 
 void MainWindow::slotRemoveSpace()
 {
     getMainTimeline()->controller()->removeSpace(-1, -1, false);
 }
 
 void MainWindow::slotRemoveAllSpace()
 {
     getMainTimeline()->controller()->removeSpace(-1, -1, true);
 }
 
 void MainWindow::slotSeparateAudioChannel()
 {
     KdenliveSettings::setDisplayallchannels(!KdenliveSettings::displayallchannels());
     getCurrentTimeline()->controller()->audioThumbFormatChanged();
 }
 
 void MainWindow::slotInsertTrack()
 {
     pCore->monitorManager()->activateMonitor(Kdenlive::ProjectMonitor);
     getCurrentTimeline()->controller()->addTrack(-1);
 }
 
 void MainWindow::slotDeleteTrack()
 {
     pCore->monitorManager()->activateMonitor(Kdenlive::ProjectMonitor);
     getCurrentTimeline()->controller()->deleteTrack(-1);
 }
 
 void MainWindow::slotShowTrackRec()
 {
     getCurrentTimeline()->controller()->switchTrackRecord();
 }
 
 void MainWindow::slotSelectTrack()
 {
     getCurrentTimeline()->controller()->selectCurrentTrack();
 }
 
 void MainWindow::slotSelectAllTracks()
 {
     if ((QApplication::focusWidget() != nullptr) && (QApplication::focusWidget()->parentWidget() != nullptr) &&
         QApplication::focusWidget()->parentWidget() == pCore->bin()) {
         pCore->bin()->selectAll();
     } else {
         getCurrentTimeline()->controller()->selectAll();
     }
 }
 
 void MainWindow::slotUnselectAllTracks()
 {
     getCurrentTimeline()->model()->requestClearSelection();
 }
 
 void MainWindow::slotEditGuide()
 {
     getCurrentTimeline()->controller()->editGuide();
 }
 
 void MainWindow::slotDeleteGuide()
 {
     getCurrentTimeline()->controller()->switchGuide(-1, true);
 }
 
 void MainWindow::slotDeleteAllGuides()
 {
     pCore->currentDoc()->getGuideModel()->removeAllMarkers();
 }
 
 void MainWindow::slotCutTimelineClip()
 {
     getMainTimeline()->controller()->cutClipUnderCursor();
 }
 
 void MainWindow::slotCutTimelineAllClips()
 {
     getMainTimeline()->controller()->cutAllClipsUnderCursor();
 }
 
 void MainWindow::slotInsertClipOverwrite()
 {
     const QString &binId = m_clipMonitor->activeClipId();
     if (binId.isEmpty()) {
         // No clip in monitor
         return;
     }
     getMainTimeline()->controller()->insertZone(binId, m_clipMonitor->getZoneInfo(), true);
 }
 
 void MainWindow::slotInsertClipInsert()
 {
     const QString &binId = m_clipMonitor->activeClipId();
     if (binId.isEmpty()) {
         // No clip in monitor
         pCore->displayMessage(i18n("No clip selected in project bin"), InformationMessage);
         return;
     }
     getMainTimeline()->controller()->insertZone(binId, m_clipMonitor->getZoneInfo(), false);
 }
 
 void MainWindow::slotExtractZone()
 {
     getMainTimeline()->controller()->extractZone(m_clipMonitor->getZoneInfo());
 }
 
 void MainWindow::slotExtractClip()
 {
     getMainTimeline()->controller()->extract();
 }
 
 void MainWindow::slotSaveZoneToBin()
 {
     getMainTimeline()->controller()->saveZone();
 }
 
 void MainWindow::slotLiftZone()
 {
     getMainTimeline()->controller()->extractZone(m_clipMonitor->getZoneInfo(), true);
 }
 
 void MainWindow::slotPreviewRender()
 {
     if (pCore->currentDoc()) {
         getCurrentTimeline()->controller()->startPreviewRender();
     }
 }
 
 void MainWindow::slotStopPreviewRender()
 {
     if (pCore->currentDoc()) {
         getCurrentTimeline()->controller()->stopPreviewRender();
     }
 }
 
 void MainWindow::slotDefinePreviewRender()
 {
     if (pCore->currentDoc()) {
         getCurrentTimeline()->controller()->addPreviewRange(true);
     }
 }
 
 void MainWindow::slotRemovePreviewRender()
 {
     if (pCore->currentDoc()) {
         getCurrentTimeline()->controller()->addPreviewRange(false);
     }
 }
 
 void MainWindow::slotClearPreviewRender(bool resetZones)
 {
     if (pCore->currentDoc()) {
         getCurrentTimeline()->controller()->clearPreviewRange(resetZones);
     }
 }
 
 void MainWindow::slotSelectTimelineClip()
 {
     getCurrentTimeline()->controller()->selectCurrentItem(ObjectType::TimelineClip, true);
 }
 
 void MainWindow::slotSelectTimelineTransition()
 {
     getCurrentTimeline()->controller()->selectCurrentItem(ObjectType::TimelineComposition, true);
 }
 
 void MainWindow::slotDeselectTimelineClip()
 {
     getCurrentTimeline()->controller()->selectCurrentItem(ObjectType::TimelineClip, false);
 }
 
 void MainWindow::slotDeselectTimelineTransition()
 {
     getCurrentTimeline()->controller()->selectCurrentItem(ObjectType::TimelineComposition, false);
 }
 
 void MainWindow::slotSelectAddTimelineClip()
 {
     getCurrentTimeline()->controller()->selectCurrentItem(ObjectType::TimelineClip, true, true);
 }
 
 void MainWindow::slotSelectAddTimelineTransition()
 {
     getCurrentTimeline()->controller()->selectCurrentItem(ObjectType::TimelineComposition, true, true);
 }
 
 void MainWindow::slotGroupClips()
 {
     getCurrentTimeline()->controller()->groupSelection();
 }
 
 void MainWindow::slotUnGroupClips()
 {
     getCurrentTimeline()->controller()->unGroupSelection();
 }
 
 void MainWindow::slotEditItemDuration()
 {
     getCurrentTimeline()->controller()->editItemDuration();
 }
 
 void MainWindow::slotAddProjectClip(const QUrl &url, const QString &folderInfo)
 {
     pCore->bin()->droppedUrls(QList<QUrl>() << url, folderInfo);
 }
 
 void MainWindow::slotAddProjectClipList(const QList<QUrl> &urls)
 {
     pCore->bin()->droppedUrls(urls);
 }
 
 void MainWindow::slotAddTransition(QAction *result)
 {
     if (!result) {
         return;
     }
     // TODO refac
     /*
     QStringList info = result->data().toStringList();
     if (info.isEmpty() || info.count() < 2) {
         return;
     }
     QDomElement transition = transitions.getEffectByTag(info.at(0), info.at(1));
     if (pCore->projectManager()->currentTimeline() && !transition.isNull()) {
         pCore->projectManager()->currentTimeline()->projectView()->slotAddTransitionToSelectedClips(transition.cloneNode().toElement());
     }
     */
 }
 
 void MainWindow::slotAddEffect(QAction *result)
 {
     qDebug() << "// EFFECTS MENU TRIGGERED: " << result->data().toString();
     if (!result) {
         return;
     }
     QString effectId = result->data().toString();
     addEffect(effectId);
 }
 
 void MainWindow::addEffect(const QString &effectId)
 {
     if (m_assetPanel->effectStackOwner().first == ObjectType::TimelineClip) {
         // Add effect to the current timeline selection
         QVariantMap effectData;
         effectData.insert(QStringLiteral("kdenlive/effect"), effectId);
         pCore->window()->getMainTimeline()->controller()->addAsset(effectData);
     } else if (m_assetPanel->effectStackOwner().first == ObjectType::TimelineTrack || m_assetPanel->effectStackOwner().first == ObjectType::BinClip || m_assetPanel->effectStackOwner().first == ObjectType::Master) {
         if (!m_assetPanel->addEffect(effectId)) {
             pCore->displayMessage(i18n("Cannot add effect to clip"), InformationMessage);
         }
     } else {
         pCore->displayMessage(i18n("Select an item to add effect"), InformationMessage);
     }
 }
 
 void MainWindow::slotZoomIn(bool zoomOnMouse)
 {
     slotSetZoom(m_zoomSlider->value() - 1, zoomOnMouse);
     slotShowZoomSliderToolTip();
 }
 
 void MainWindow::slotZoomOut(bool zoomOnMouse)
 {
     slotSetZoom(m_zoomSlider->value() + 1, zoomOnMouse);
     slotShowZoomSliderToolTip();
 }
 
 void MainWindow::slotFitZoom()
 {
     m_timelineTabs->fitZoom();
 }
 
 void MainWindow::slotSetZoom(int value, bool zoomOnMouse)
 {
     value = qBound(m_zoomSlider->minimum(), value, m_zoomSlider->maximum());
     m_timelineTabs->changeZoom(value, zoomOnMouse);
     updateZoomSlider(value);
 }
 
 void MainWindow::updateZoomSlider(int value)
 {
     slotUpdateZoomSliderToolTip(value);
     KdenliveDoc *project = pCore->currentDoc();
     if (project) {
         project->setZoom(value);
     }
     m_zoomOut->setEnabled(value < m_zoomSlider->maximum());
     m_zoomIn->setEnabled(value > m_zoomSlider->minimum());
     QSignalBlocker blocker(m_zoomSlider);
     m_zoomSlider->setValue(value);
 }
 
 void MainWindow::slotShowZoomSliderToolTip(int zoomlevel)
 {
     if (zoomlevel != -1) {
         slotUpdateZoomSliderToolTip(zoomlevel);
     }
 
     QPoint global = m_zoomSlider->rect().topLeft();
     global.ry() += m_zoomSlider->height() / 2;
     QHelpEvent toolTipEvent(QEvent::ToolTip, QPoint(0, 0), m_zoomSlider->mapToGlobal(global));
     QApplication::sendEvent(m_zoomSlider, &toolTipEvent);
 }
 
 void MainWindow::slotUpdateZoomSliderToolTip(int zoomlevel)
 {
     int max = m_zoomSlider->maximum() + 1;
     m_zoomSlider->setToolTip(i18n("Zoom Level: %1/%2", max - zoomlevel, max));
 }
 
 void MainWindow::customEvent(QEvent *e)
 {
     if (e->type() == QEvent::User) {
         m_messageLabel->setMessage(static_cast<MltErrorEvent *>(e)->message(), MltError);
     }
 }
 
 void MainWindow::slotSnapRewind()
 {
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->gotoPreviousSnap();
     } else {
         m_clipMonitor->slotSeekToPreviousSnap();
     }
 }
 
 void MainWindow::slotSnapForward()
 {
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->gotoNextSnap();
     } else {
         m_clipMonitor->slotSeekToNextSnap();
     }
 }
 
 void MainWindow::slotGuideRewind()
 {
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->gotoPreviousGuide();
     } else {
         m_clipMonitor->slotSeekToPreviousSnap();
     }
 }
 
 void MainWindow::slotGuideForward()
 {
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->gotoNextGuide();
     } else {
         m_clipMonitor->slotSeekToNextSnap();
     }
 }
 
 void MainWindow::slotClipStart()
 {
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->seekCurrentClip(false);
     } else {
         m_clipMonitor->slotStart();
     }
 }
 
 void MainWindow::slotClipEnd()
 {
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->controller()->seekCurrentClip(true);
     } else {
         m_clipMonitor->slotEnd();
     }
 }
 
 void MainWindow::slotChangeTool(QAction *action)
 {
     if (action == m_buttonSelectTool) {
         slotSetTool(SelectTool);
     } else if (action == m_buttonRazorTool) {
         slotSetTool(RazorTool);
     } else if (action == m_buttonSpacerTool) {
         slotSetTool(SpacerTool);
     }
 }
 
 void MainWindow::slotChangeEdit(QAction *action)
 {
     TimelineMode::EditMode mode = TimelineMode::NormalEdit;
     if (action == m_overwriteEditTool) {
         mode = TimelineMode::OverwriteEdit;
     } else if (action == m_insertEditTool) {
         mode = TimelineMode::InsertEdit;
     }
     getMainTimeline()->controller()->getModel()->setEditMode(mode);
 }
 
 void MainWindow::slotSetTool(ProjectTool tool)
 {
     if (pCore->currentDoc()) {
         // pCore->currentDoc()->setTool(tool);
         QString message;
         switch (tool) {
         case SpacerTool:
             message = i18n("Ctrl + click to use spacer on current track only");
             break;
         case RazorTool:
             message = i18n("Click on a clip to cut it, Shift + move to preview cut frame");
             break;
         default:
             message = i18n("Shift + click to create a selection rectangle, Ctrl + click to add an item to selection");
             break;
         }
         m_messageLabel->setMessage(message, InformationMessage);
         getMainTimeline()->setTool(tool);
     }
 }
 
 void MainWindow::slotCopy()
 {
     getMainTimeline()->controller()->copyItem();
 }
 
 void MainWindow::slotPaste()
 {
     getMainTimeline()->controller()->pasteItem();
 }
 
 void MainWindow::slotPasteEffects()
 {
     getMainTimeline()->controller()->pasteEffects();
 }
 
 void MainWindow::slotClipInTimeline(const QString &clipId, const QList<int> &ids)
 {
     Q_UNUSED(clipId)
     QMenu *inTimelineMenu = static_cast<QMenu *>(factory()->container(QStringLiteral("clip_in_timeline"), this));
     QList<QAction *> actionList;
     for (int i = 0; i < ids.count(); ++i) {
         QString track = getMainTimeline()->controller()->getTrackNameFromIndex(pCore->getItemTrack(ObjectId(ObjectType::TimelineClip, ids.at(i))));
         QString start = pCore->currentDoc()->timecode().getTimecodeFromFrames(pCore->getItemPosition(ObjectId(ObjectType::TimelineClip, ids.at(i))));
         int j = 0;
         QAction *a = new QAction(track + QStringLiteral(": ") + start, inTimelineMenu);
         a->setData(ids.at(i));
         connect(a, &QAction::triggered, this, &MainWindow::slotSelectClipInTimeline);
         while (j < actionList.count()) {
             if (actionList.at(j)->text() > a->text()) {
                 break;
             }
             j++;
         }
         actionList.insert(j, a);
     }
     QList<QAction *> list = inTimelineMenu->actions();
     unplugActionList(QStringLiteral("timeline_occurences"));
     qDeleteAll(list);
     plugActionList(QStringLiteral("timeline_occurences"), actionList);
 
     if (actionList.isEmpty()) {
         inTimelineMenu->setEnabled(false);
     } else {
         inTimelineMenu->setEnabled(true);
     }
 }
 
 void MainWindow::slotClipInProjectTree()
 {
     QList<int> ids = getMainTimeline()->controller()->selection();
     if (!ids.isEmpty()) {
         m_projectBinDock->raise();
         ObjectId id(ObjectType::TimelineClip, ids.constFirst());
         int start = pCore->getItemIn(id);
         int duration = pCore->getItemDuration(id);
         QPoint zone(start, start + duration);
         qDebug() << " - - selecting clip on monitor, zone: " << zone;
         int pos = m_projectMonitor->position();
         int itemPos = pCore->getItemPosition(id);
         if (pos >= itemPos && pos < itemPos + duration) {
             pos -= (itemPos - start);
         } else {
             pos = -1;
         }
         pCore->selectBinClip(getMainTimeline()->controller()->getClipBinId(ids.constFirst()), pos, zone);
     }
 }
 
 void MainWindow::slotSelectClipInTimeline()
 {
     pCore->monitorManager()->activateMonitor(Kdenlive::ProjectMonitor);
     auto *action = qobject_cast<QAction *>(sender());
     int clipId = action->data().toInt();
     getMainTimeline()->controller()->focusItem(clipId);
 }
 
 /** Gets called when the window gets hidden */
 void MainWindow::hideEvent(QHideEvent * /*event*/)
 {
     if (isMinimized() && pCore->monitorManager()) {
         pCore->monitorManager()->pauseActiveMonitor();
     }
 }
 
 /*void MainWindow::slotSaveZone(Render *render, const QPoint &zone, DocClipBase *baseClip, QUrl path)
 {
     QPointer<QDialog> dialog = new QDialog(this);
     dialog->setWindowTitle("Save clip zone");
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     QVBoxLayout *mainLayout = new QVBoxLayout;
     dialog->setLayout(mainLayout);
 
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     dialog->connect(buttonBox, SIGNAL(accepted()), dialog, SLOT(accept()));
     dialog->connect(buttonBox, SIGNAL(rejected()), dialog, SLOT(reject()));
 
     QLabel *label1 = new QLabel(i18n("Save clip zone as:"), this);
     if (path.isEmpty()) {
         QString tmppath = pCore->currentDoc()->projectFolder().path() + QDir::separator();
         if (baseClip == nullptr) {
             tmppath.append("untitled.mlt");
         } else {
             tmppath.append((baseClip->name().isEmpty() ? baseClip->fileURL().fileName() : baseClip->name()) + '-' + QString::number(zone.x()).rightJustified(4,
 '0') + QStringLiteral(".mlt"));
         }
         path = QUrl(tmppath);
     }
     KUrlRequester *url = new KUrlRequester(path, this);
     url->setFilter("video/mlt-playlist");
     QLabel *label2 = new QLabel(i18n("Description:"), this);
     QLineEdit *edit = new QLineEdit(this);
     mainLayout->addWidget(label1);
     mainLayout->addWidget(url);
     mainLayout->addWidget(label2);
     mainLayout->addWidget(edit);
     mainLayout->addWidget(buttonBox);
 
     if (dialog->exec() == QDialog::Accepted) {
         if (QFile::exists(url->url().path())) {
             if (KMessageBox::questionYesNo(this, i18n("File %1 already exists.\nDo you want to overwrite it?", url->url().path())) == KMessageBox::No) {
                 slotSaveZone(render, zone, baseClip, url->url());
                 delete dialog;
                 return;
             }
         }
         if (baseClip && !baseClip->fileURL().isEmpty()) {
             // create zone from clip url, so that we don't have problems with proxy clips
             QProcess p;
             QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
             env.remove("MLT_PROFILE");
             p.setProcessEnvironment(env);
             p.start(KdenliveSettings::rendererpath(), QStringList() << baseClip->fileURL().toLocalFile() << "in=" + QString::number(zone.x()) << "out=" +
 QString::number(zone.y()) << "-consumer" << "xml:" + url->url().path());
             if (!p.waitForStarted(3000)) {
                 KMessageBox::sorry(this, i18n("Cannot start MLT's renderer:\n%1", KdenliveSettings::rendererpath()));
             }
             else if (!p.waitForFinished(5000)) {
                 KMessageBox::sorry(this, i18n("Timeout while creating xml output"));
             }
         }
         else render->saveZone(url->url(), edit->text(), zone);
     }
     delete dialog;
 }*/
 
 void MainWindow::slotResizeItemStart()
 {
     getMainTimeline()->controller()->setInPoint();
 }
 
 void MainWindow::slotResizeItemEnd()
 {
     getMainTimeline()->controller()->setOutPoint();
 }
 
 int MainWindow::getNewStuff(const QString &configFile)
 {
     KNS3::Entry::List entries;
     QPointer<KNS3::DownloadDialog> dialog = new KNS3::DownloadDialog(configFile);
     if (dialog->exec() != 0) {
         entries = dialog->changedEntries();
     }
     for (const KNS3::Entry &entry : entries) {
         if (entry.status() == KNS3::Entry::Installed) {
             qCDebug(KDENLIVE_LOG) << "// Installed files: " << entry.installedFiles();
         }
     }
     delete dialog;
     return entries.size();
 }
 
 void MainWindow::slotGetNewKeyboardStuff(QComboBox *schemesList)
 {
     if (getNewStuff(QStringLiteral(":data/kdenlive_keyboardschemes.knsrc")) > 0) {
         // Refresh keyboard schemes list (schemes list creation code copied from KShortcutSchemesEditor)
         QStringList schemes;
         schemes << QStringLiteral("Default");
         // List files in the shortcuts subdir, each one is a scheme. See KShortcutSchemesHelper::{shortcutSchemeFileName,exportActionCollection}
         const QStringList shortcutsDirs = QStandardPaths::locateAll(
             QStandardPaths::GenericDataLocation, QCoreApplication::applicationName() + QStringLiteral("/shortcuts"), QStandardPaths::LocateDirectory);
         qCDebug(KDENLIVE_LOG) << "shortcut scheme dirs:" << shortcutsDirs;
         Q_FOREACH (const QString &dir, shortcutsDirs) {
             Q_FOREACH (const QString &file, QDir(dir).entryList(QDir::Files | QDir::NoDotAndDotDot)) {
                 qCDebug(KDENLIVE_LOG) << "shortcut scheme file:" << file;
                 schemes << file;
             }
         }
         schemesList->clear();
         schemesList->addItems(schemes);
     }
 }
 
 void MainWindow::slotAutoTransition()
 {
     // TODO refac
     /*
     if (pCore->projectManager()->currentTimeline()) {
         pCore->projectManager()->currentTimeline()->projectView()->autoTransition();
     }
     */
 }
 
 void MainWindow::slotSplitAV()
 {
     getMainTimeline()->controller()->splitAV();
 }
 
 void MainWindow::slotSwitchClip()
 {
     getMainTimeline()->controller()->switchEnableState();
 }
 
 void MainWindow::slotSetAudioAlignReference()
 {
     getMainTimeline()->controller()->setAudioRef();
 }
 
 void MainWindow::slotAlignAudio()
 {
     getMainTimeline()->controller()->alignAudio();
 }
 
 void MainWindow::slotUpdateClipType(QAction *action)
 {
     Q_UNUSED(action)
     // TODO refac
     /*
     if (pCore->projectManager()->currentTimeline()) {
         PlaylistState::ClipState state = (PlaylistState::ClipState)action->data().toInt();
         pCore->projectManager()->currentTimeline()->projectView()->setClipType(state);
     }
     */
 }
 
 void MainWindow::slotUpdateTimelineView(QAction *action)
 {
     int viewMode = action->data().toInt();
     KdenliveSettings::setAudiotracksbelow(viewMode);
     getMainTimeline()->controller()->getModel()->_resetView();
 }
 
 void MainWindow::slotDvdWizard(const QString &url)
 {
     // We must stop the monitors since we create a new on in the dvd wizard
     QPointer<DvdWizard> w = new DvdWizard(pCore->monitorManager(), url, this);
     w->exec();
     delete w;
     pCore->monitorManager()->activateMonitor(Kdenlive::ClipMonitor);
 }
 
 void MainWindow::slotShowTimeline(bool show)
 {
     if (!show) {
         m_timelineState = saveState();
         centralWidget()->setHidden(true);
     } else {
         centralWidget()->setHidden(false);
         restoreState(m_timelineState);
     }
 }
 
 void MainWindow::loadClipActions()
 {
     unplugActionList(QStringLiteral("add_effect"));
     plugActionList(QStringLiteral("add_effect"), m_effectsMenu->actions());
 
     QList<QAction *> clipJobActions = getExtraActions(QStringLiteral("clipjobs"));
     unplugActionList(QStringLiteral("clip_jobs"));
     plugActionList(QStringLiteral("clip_jobs"), clipJobActions);
 
     QList<QAction *> atcActions = getExtraActions(QStringLiteral("audiotranscoderslist"));
     unplugActionList(QStringLiteral("audio_transcoders_list"));
     plugActionList(QStringLiteral("audio_transcoders_list"), atcActions);
 
     QList<QAction *> tcActions = getExtraActions(QStringLiteral("transcoderslist"));
     unplugActionList(QStringLiteral("transcoders_list"));
     plugActionList(QStringLiteral("transcoders_list"), tcActions);
 }
 
 void MainWindow::loadDockActions()
 {
     QList<QAction *> list = kdenliveCategoryMap.value(QStringLiteral("interface"))->actions();
     // Sort actions
     QMap<QString, QAction *> sorted;
     QStringList sortedList;
     for (QAction *a : list) {
         sorted.insert(a->text(), a);
         sortedList << a->text();
     }
     QList<QAction *> orderedList;
     sortedList.sort(Qt::CaseInsensitive);
     for (const QString &text : sortedList) {
         orderedList << sorted.value(text);
     }
     unplugActionList(QStringLiteral("dock_actions"));
     plugActionList(QStringLiteral("dock_actions"), orderedList);
 }
 
 void MainWindow::buildDynamicActions()
 {
     KActionCategory *ts = nullptr;
     if (kdenliveCategoryMap.contains(QStringLiteral("clipjobs"))) {
         ts = kdenliveCategoryMap.take(QStringLiteral("clipjobs"));
         delete ts;
     }
     ts = new KActionCategory(i18n("Clip Jobs"), m_extraFactory->actionCollection());
 
     Mlt::Profile profile;
     std::unique_ptr<Mlt::Filter> filter;
     for (const QString &stab : {QStringLiteral("vidstab")}) {
         filter = std::make_unique<Mlt::Filter>(profile, stab.toUtf8().constData());
         if ((filter != nullptr) && filter->is_valid()) {
             QAction *action = new QAction(i18n("Stabilize (%1)", stab), m_extraFactory->actionCollection());
             ts->addAction(action->text(), action);
             connect(action, &QAction::triggered, [stab]() {
                 pCore->jobManager()->startJob<StabilizeJob>(pCore->bin()->selectedClipsIds(true), {},
                                                             i18np("Stabilize clip", "Stabilize clips", pCore->bin()->selectedClipsIds().size()), stab);
             });
             break;
         }
     }
     filter = std::make_unique<Mlt::Filter>(profile, "motion_est");
     if (filter) {
         if (filter->is_valid()) {
             QAction *action = new QAction(i18n("Automatic scene split"), m_extraFactory->actionCollection());
             ts->addAction(action->text(), action);
             connect(action, &QAction::triggered,
                     [&]() { pCore->jobManager()->startJob<SceneSplitJob>(pCore->bin()->selectedClipsIds(true), {}, i18n("Scene detection")); });
         }
     }
     if (true /* TODO: check if timewarp producer is available */) {
         QAction *action = new QAction(i18n("Duplicate clip with speed change"), m_extraFactory->actionCollection());
         ts->addAction(action->text(), action);
         connect(action, &QAction::triggered,
                 [&]() { pCore->jobManager()->startJob<SpeedJob>(pCore->bin()->selectedClipsIds(true), {}, i18n("Change clip speed")); });
     }
 
     // TODO refac reimplement analyseclipjob
     /*
     QAction *action = new QAction(i18n("Analyse keyframes"), m_extraFactory->actionCollection());
     QStringList stabJob(QString::number((int)AbstractClipJob::ANALYSECLIPJOB));
     action->setData(stabJob);
     ts->addAction(action->text(), action);
     connect(action, &QAction::triggered, pCore->bin(), &Bin::slotStartClipJob);
     */
     kdenliveCategoryMap.insert(QStringLiteral("clipjobs"), ts);
 
     if (kdenliveCategoryMap.contains(QStringLiteral("transcoderslist"))) {
         ts = kdenliveCategoryMap.take(QStringLiteral("transcoderslist"));
         delete ts;
     }
     if (kdenliveCategoryMap.contains(QStringLiteral("audiotranscoderslist"))) {
         ts = kdenliveCategoryMap.take(QStringLiteral("audiotranscoderslist"));
         delete ts;
     }
     // transcoders
     ts = new KActionCategory(i18n("Transcoders"), m_extraFactory->actionCollection());
     KActionCategory *ats = new KActionCategory(i18n("Extract Audio"), m_extraFactory->actionCollection());
     KSharedConfigPtr config =
         KSharedConfig::openConfig(QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("kdenlivetranscodingrc")), KConfig::CascadeConfig);
     KConfigGroup transConfig(config, "Transcoding");
     // read the entries
     QMap<QString, QString> profiles = transConfig.entryMap();
     QMapIterator<QString, QString> i(profiles);
     while (i.hasNext()) {
         i.next();
         QStringList transList;
         transList << i.value().split(QLatin1Char(';'));
         auto *a = new QAction(i.key(), m_extraFactory->actionCollection());
         a->setData(transList);
         if (transList.count() > 1) {
             a->setToolTip(transList.at(1));
         }
         connect(a, &QAction::triggered, [&, a]() {
             QStringList transcodeData = a->data().toStringList();
             pCore->jobManager()->startJob<TranscodeJob>(pCore->bin()->selectedClipsIds(true), -1, QString(), transcodeData.first());
         });
         if (transList.count() > 2 && transList.at(2) == QLatin1String("audio")) {
             // This is an audio transcoding action
             ats->addAction(i.key(), a);
         } else {
             ts->addAction(i.key(), a);
         }
     }
     kdenliveCategoryMap.insert(QStringLiteral("transcoderslist"), ts);
     kdenliveCategoryMap.insert(QStringLiteral("audiotranscoderslist"), ats);
 
     // Populate View menu with show / hide actions for dock widgets
     KActionCategory *guiActions = nullptr;
     if (kdenliveCategoryMap.contains(QStringLiteral("interface"))) {
         guiActions = kdenliveCategoryMap.take(QStringLiteral("interface"));
         delete guiActions;
     }
     guiActions = new KActionCategory(i18n("Interface"), actionCollection());
     QAction *showTimeline = new QAction(i18n("Timeline"), this);
     showTimeline->setCheckable(true);
     showTimeline->setChecked(true);
     connect(showTimeline, &QAction::triggered, this, &MainWindow::slotShowTimeline);
     guiActions->addAction(showTimeline->text(), showTimeline);
     actionCollection()->addAction(showTimeline->text(), showTimeline);
 
     QList<QDockWidget *> docks = findChildren<QDockWidget *>();
     for (auto dock : docks) {
         QAction *dockInformations = dock->toggleViewAction();
         if (!dockInformations) {
             continue;
         }
         dockInformations->setChecked(!dock->isHidden());
         guiActions->addAction(dockInformations->text(), dockInformations);
     }
     kdenliveCategoryMap.insert(QStringLiteral("interface"), guiActions);
 }
 
 QList<QAction *> MainWindow::getExtraActions(const QString &name)
 {
     if (!kdenliveCategoryMap.contains(name)) {
         return QList<QAction *>();
     }
     return kdenliveCategoryMap.value(name)->actions();
 }
 
 void MainWindow::slotTranscode(const QStringList &urls)
 {
     Q_ASSERT(!urls.isEmpty());
     QString params;
     QString desc;
     ClipTranscode *d = new ClipTranscode(urls, params, QStringList(), desc, pCore->bin()->getCurrentFolder());
     connect(d, &ClipTranscode::addClip, this, &MainWindow::slotAddProjectClip);
     d->show();
 }
 
 void MainWindow::slotTranscodeClip()
 {
     const QString dialogFilter = ClipCreationDialog::getExtensionsFilter(QStringList() << i18n("All Files") + QStringLiteral(" (*)"));
     QString clipFolder = KRecentDirs::dir(QStringLiteral(":KdenliveClipFolder"));
     QStringList urls = QFileDialog::getOpenFileNames(this, i18n("Files to transcode"), clipFolder, dialogFilter);
     if (urls.isEmpty()) {
         return;
     }
     slotTranscode(urls);
 }
 
 void MainWindow::slotSetDocumentRenderProfile(const QMap<QString, QString> &props)
 {
     KdenliveDoc *project = pCore->currentDoc();
     bool modified = false;
     QMapIterator<QString, QString> i(props);
     while (i.hasNext()) {
         i.next();
         if (project->getDocumentProperty(i.key()) == i.value()) {
             continue;
         }
         project->setDocumentProperty(i.key(), i.value());
         modified = true;
     }
     if (modified) {
         project->setModified();
     }
 }
 
 void MainWindow::slotUpdateTimecodeFormat(int ix)
 {
     KdenliveSettings::setFrametimecode(ix == 1);
     m_clipMonitor->updateTimecodeFormat();
     m_projectMonitor->updateTimecodeFormat();
     // TODO refac: reimplement ?
     // m_effectStack->transitionConfig()->updateTimecodeFormat();
     // m_effectStack->updateTimecodeFormat();
     pCore->bin()->updateTimecodeFormat();
     getMainTimeline()->controller()->frameFormatChanged();
     m_timeFormatButton->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
 }
 
 void MainWindow::slotRemoveFocus()
 {
     getMainTimeline()->setFocus();
 }
 
 void MainWindow::slotShutdown()
 {
     pCore->currentDoc()->setModified(false);
     // Call shutdown
     QDBusConnectionInterface *interface = QDBusConnection::sessionBus().interface();
     if ((interface != nullptr) && interface->isServiceRegistered(QStringLiteral("org.kde.ksmserver"))) {
         QDBusInterface smserver(QStringLiteral("org.kde.ksmserver"), QStringLiteral("/KSMServer"), QStringLiteral("org.kde.KSMServerInterface"));
         smserver.call(QStringLiteral("logout"), 1, 2, 2);
     } else if ((interface != nullptr) && interface->isServiceRegistered(QStringLiteral("org.gnome.SessionManager"))) {
         QDBusInterface smserver(QStringLiteral("org.gnome.SessionManager"), QStringLiteral("/org/gnome/SessionManager"),
                                 QStringLiteral("org.gnome.SessionManager"));
         smserver.call(QStringLiteral("Shutdown"));
     }
 }
 
 void MainWindow::slotSwitchMonitors()
 {
     pCore->monitorManager()->slotSwitchMonitors(!m_clipMonitor->isActive());
     if (m_projectMonitor->isActive()) {
         getMainTimeline()->setFocus();
     } else {
         pCore->bin()->focusBinView();
     }
 }
 
 void MainWindow::slotSwitchMonitorOverlay(QAction *action)
 {
     if (pCore->monitorManager()->isActive(Kdenlive::ClipMonitor)) {
         m_clipMonitor->switchMonitorInfo(action->data().toInt());
     } else {
         m_projectMonitor->switchMonitorInfo(action->data().toInt());
     }
 }
 
 void MainWindow::slotSwitchDropFrames(bool drop)
 {
     m_clipMonitor->switchDropFrames(drop);
     m_projectMonitor->switchDropFrames(drop);
 }
 
 void MainWindow::slotSetMonitorGamma(int gamma)
 {
     KdenliveSettings::setMonitor_gamma(gamma);
     m_clipMonitor->updateMonitorGamma();
     m_projectMonitor->updateMonitorGamma();
 }
 
 void MainWindow::slotInsertZoneToTree()
 {
     if (!m_clipMonitor->isActive() || m_clipMonitor->currentController() == nullptr) {
         return;
     }
     QPoint info = m_clipMonitor->getZoneInfo();
     QString id;
     pCore->projectItemModel()->requestAddBinSubClip(id, info.x(), info.y(), {}, m_clipMonitor->activeClipId());
 }
 
 void MainWindow::slotMonitorRequestRenderFrame(bool request)
 {
     if (request) {
         m_projectMonitor->sendFrameForAnalysis(true);
         return;
     }
     for (int i = 0; i < m_gfxScopesList.count(); ++i) {
         if (m_gfxScopesList.at(i)->isVisible() && tabifiedDockWidgets(m_gfxScopesList.at(i)).isEmpty() &&
             static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->autoRefreshEnabled()) {
             request = true;
             break;
         }
     }
 
 #ifdef DEBUG_MAINW
     qCDebug(KDENLIVE_LOG) << "Any scope accepting new frames? " << request;
 #endif
     if (!request) {
         m_projectMonitor->sendFrameForAnalysis(false);
     }
 }
 
 void MainWindow::slotUpdateProxySettings()
 {
     KdenliveDoc *project = pCore->currentDoc();
     if (m_renderWidget) {
         m_renderWidget->updateProxyConfig(project->useProxy());
     }
     pCore->bin()->refreshProxySettings();
 }
 
 void MainWindow::slotArchiveProject()
 {
     KdenliveDoc *doc = pCore->currentDoc();
     QDomDocument xmlDoc = doc->xmlSceneList(m_projectMonitor->sceneList(doc->url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).toLocalFile()));
     if (xmlDoc.isNull()) {
         KMessageBox::error(this, i18n("Project file could not be saved for archiving."));
         return;
     }
     QPointer<ArchiveWidget> d(new ArchiveWidget(doc->url().fileName(), xmlDoc, getMainTimeline()->controller()->extractCompositionLumas(), this));
     if (d->exec() != 0) {
         m_messageLabel->setMessage(i18n("Archiving project"), OperationCompletedMessage);
     }
 }
 
 void MainWindow::slotDownloadResources()
 {
     QString currentFolder;
     if (pCore->currentDoc()) {
         currentFolder = pCore->currentDoc()->projectDataFolder();
     } else {
         currentFolder = KdenliveSettings::defaultprojectfolder();
     }
     auto *d = new ResourceWidget(currentFolder);
     connect(d, &ResourceWidget::addClip, this, &MainWindow::slotAddProjectClip);
     d->show();
 }
 
 void MainWindow::slotProcessImportKeyframes(GraphicsRectItem type, const QString &tag, const QString &keyframes)
 {
     Q_UNUSED(keyframes)
     Q_UNUSED(tag)
     if (type == AVWidget) {
         // This data should be sent to the effect stack
         // TODO REFAC reimplement
         // m_effectStack->setKeyframes(tag, data);
     } else if (type == TransitionWidget) {
         // This data should be sent to the transition stack
         // TODO REFAC reimplement
         // m_effectStack->transitionConfig()->setKeyframes(tag, data);
     } else {
         // Error
     }
 }
 
 void MainWindow::slotAlignPlayheadToMousePos()
 {
     pCore->monitorManager()->activateMonitor(Kdenlive::ProjectMonitor);
     getMainTimeline()->controller()->seekToMouse();
 }
 
 void MainWindow::triggerKey(QKeyEvent *ev)
 {
     // Hack: The QQuickWindow that displays fullscreen monitor does not integrate quith QActions.
     // so on keypress events we parse keys and check for shortcuts in all existing actions
     QKeySequence seq;
     // Remove the Num modifier or some shortcuts like "*" will not work
     if (ev->modifiers() != Qt::KeypadModifier) {
         seq = QKeySequence(ev->key() + static_cast<int>(ev->modifiers()));
     } else {
         seq = QKeySequence(ev->key());
     }
     QList<KActionCollection *> collections = KActionCollection::allCollections();
     for (int i = 0; i < collections.count(); ++i) {
         KActionCollection *coll = collections.at(i);
         for (QAction *tempAction : coll->actions()) {
             if (tempAction->shortcuts().contains(seq)) {
                 // Trigger action
                 tempAction->trigger();
                 ev->accept();
                 return;
             }
         }
     }
 }
 
 QDockWidget *MainWindow::addDock(const QString &title, const QString &objectName, QWidget *widget, Qt::DockWidgetArea area)
 {
     QDockWidget *dockWidget = new QDockWidget(title, this);
     dockWidget->setObjectName(objectName);
     dockWidget->setWidget(widget);
     addDockWidget(area, dockWidget);
     return dockWidget;
 }
 
 void MainWindow::slotUpdateDockLocation(Qt::DockWidgetArea dockLocationArea)
 {
     qDebug()<<"== UPDATING DOCK LOCATION FOR: "<<dockLocationArea;
     if (dockLocationArea == Qt::NoDockWidgetArea) {
         updateDockTitleBars(false);
     } else {
         updateDockTitleBars(true);
     }
 }
 
 void MainWindow::slotUpdateMonitorOverlays(int id, int code)
 {
     QMenu *monitorOverlay = static_cast<QMenu *>(factory()->container(QStringLiteral("monitor_config_overlay"), this));
     if (!monitorOverlay) {
         return;
     }
     QList<QAction *> actions = monitorOverlay->actions();
     for (QAction *ac : actions) {
         int mid = ac->data().toInt();
         if (mid == 0x010) {
             ac->setVisible(id == Kdenlive::ClipMonitor);
         }
         ac->setChecked(code & mid);
     }
 }
 
 void MainWindow::slotChangeStyle(QAction *a)
 {
     QString style = a->data().toString();
     KdenliveSettings::setWidgetstyle(style);
     doChangeStyle();
     // Monitor refresh is necessary
     if (pCore->monitorManager()->isActive(Kdenlive::ClipMonitor)) {
         m_clipMonitorDock->raise();
     } else {
         m_projectMonitorDock->raise();
     }
 }
 
 void MainWindow::doChangeStyle()
 {
     QString newStyle = KdenliveSettings::widgetstyle();
     if (newStyle.isEmpty() || newStyle == QStringLiteral("Default")) {
         newStyle = defaultStyle("Breeze");
     }
     QApplication::setStyle(QStyleFactory::create(newStyle));
 }
 
 bool MainWindow::isTabbedWith(QDockWidget *widget, const QString &otherWidget)
 {
     QList<QDockWidget *> tabbed = tabifiedDockWidgets(widget);
     for (auto tab : tabbed) {
         if (tab->objectName() == otherWidget) {
             return true;
         }
     }
     return false;
 }
 
 void MainWindow::updateDockTitleBars(bool isTopLevel)
 {
     if (!KdenliveSettings::showtitlebars() && !isTopLevel) {
         return;
     }
     QList<QDockWidget *> docks = findChildren<QDockWidget *>();
     //qDebug()<<"=== FOUND DOCKS: "<<docks.count();
     for (QDockWidget *dock : docks) {
         QWidget *bar = dock->titleBarWidget();
         if (dock->isFloating()) {
             if (bar) {
                 dock->setTitleBarWidget(nullptr);
                 delete bar;
             }
             continue;
         }
         QList<QDockWidget *> docked = pCore->window()->tabifiedDockWidgets(dock);
         if (docked.isEmpty()) {
             if (bar) {
                 dock->setTitleBarWidget(nullptr);
                 delete bar;
             }
             continue;
         }
         bool hasVisibleDockSibling = false;
         for (QDockWidget *sub : docked) {
             if (sub->toggleViewAction()->isChecked() && !sub->isTopLevel()) {
                 // we have another docked widget, so tabs are visible and can be used instead of title bars
                 hasVisibleDockSibling = true;
                 break;
             }
         }
         if (!hasVisibleDockSibling) {
             if (bar) {
                 dock->setTitleBarWidget(nullptr);
                 delete bar;
             }
             continue;
         }
         if (!bar) {
             dock->setTitleBarWidget(new QWidget);
         }
     }
 }
 
 void MainWindow::slotToggleAutoPreview(bool enable)
 {
     KdenliveSettings::setAutopreview(enable);
     if (enable && getMainTimeline()) {
         getMainTimeline()->controller()->startPreviewRender();
     }
 }
 
 void MainWindow::configureToolbars()
 {
     // Since our timeline toolbar is a non-standard toolbar (as it is docked in a custom widget, not
     // in a QToolBarDockArea, we have to hack KXmlGuiWindow to avoid a crash when saving toolbar config.
     // This is why we hijack the configureToolbars() and temporarily move the toolbar to a standard location
     auto *ctnLay = (QVBoxLayout *)m_timelineToolBarContainer->layout();
     ctnLay->removeWidget(m_timelineToolBar);
     addToolBar(Qt::BottomToolBarArea, m_timelineToolBar);
     auto *toolBarEditor = new KEditToolBar(guiFactory(), this);
     toolBarEditor->setAttribute(Qt::WA_DeleteOnClose);
     connect(toolBarEditor, SIGNAL(newToolBarConfig()), SLOT(saveNewToolbarConfig()));
     connect(toolBarEditor, &QDialog::finished, this, &MainWindow::rebuildTimlineToolBar);
     toolBarEditor->show();
 }
 
 void MainWindow::rebuildTimlineToolBar()
 {
     // Timeline toolbar settings changed, we can now re-add our toolbar to custom location
     m_timelineToolBar = toolBar(QStringLiteral("timelineToolBar"));
     removeToolBar(m_timelineToolBar);
     m_timelineToolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     auto *ctnLay = (QVBoxLayout *)m_timelineToolBarContainer->layout();
     if (ctnLay) {
         ctnLay->insertWidget(0, m_timelineToolBar);
     }
     m_timelineToolBar->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_timelineToolBar, &QWidget::customContextMenuRequested, this, &MainWindow::showTimelineToolbarMenu);
     m_timelineToolBar->setVisible(true);
 }
 
 void MainWindow::showTimelineToolbarMenu(const QPoint &pos)
 {
     QMenu menu;
     menu.addAction(actionCollection()->action(KStandardAction::name(KStandardAction::ConfigureToolbars)));
     QMenu *contextSize = new QMenu(i18n("Icon Size"));
     menu.addMenu(contextSize);
     auto *sizeGroup = new QActionGroup(contextSize);
     int currentSize = m_timelineToolBar->iconSize().width();
     QAction *a = new QAction(i18nc("@item:inmenu Icon size", "Default"), contextSize);
     a->setData(m_timelineToolBar->iconSizeDefault());
     a->setCheckable(true);
     if (m_timelineToolBar->iconSizeDefault() == currentSize) {
         a->setChecked(true);
     }
     a->setActionGroup(sizeGroup);
     contextSize->addAction(a);
     KIconTheme *theme = KIconLoader::global()->theme();
     QList<int> avSizes;
     if (theme) {
         avSizes = theme->querySizes(KIconLoader::Toolbar);
     }
 
     std::sort(avSizes.begin(), avSizes.end());
 
     if (avSizes.count() < 10) {
         // Fixed or threshold type icons
         Q_FOREACH (int it, avSizes) {
             QString text;
             if (it < 19) {
                 text = i18n("Small (%1x%2)", it, it);
             } else if (it < 25) {
                 text = i18n("Medium (%1x%2)", it, it);
             } else if (it < 35) {
                 text = i18n("Large (%1x%2)", it, it);
             } else {
                 text = i18n("Huge (%1x%2)", it, it);
             }
 
             // save the size in the contextIconSizes map
             auto *sizeAction = new QAction(text, contextSize);
             sizeAction->setData(it);
             sizeAction->setCheckable(true);
             sizeAction->setActionGroup(sizeGroup);
             if (it == currentSize) {
                 sizeAction->setChecked(true);
             }
             contextSize->addAction(sizeAction);
         }
     } else {
         // Scalable icons.
         const int progression[] = {16, 22, 32, 48, 64, 96, 128, 192, 256};
 
         for (int i : progression) {
             Q_FOREACH (int it, avSizes) {
                 if (it >= i) {
                     QString text;
                     if (it < 19) {
                         text = i18n("Small (%1x%2)", it, it);
                     } else if (it < 25) {
                         text = i18n("Medium (%1x%2)", it, it);
                     } else if (it < 35) {
                         text = i18n("Large (%1x%2)", it, it);
                     } else {
                         text = i18n("Huge (%1x%2)", it, it);
                     }
 
                     // save the size in the contextIconSizes map
                     auto *sizeAction = new QAction(text, contextSize);
                     sizeAction->setData(it);
                     sizeAction->setCheckable(true);
                     sizeAction->setActionGroup(sizeGroup);
                     if (it == currentSize) {
                         sizeAction->setChecked(true);
                     }
                     contextSize->addAction(sizeAction);
                     break;
                 }
             }
         }
     }
     connect(contextSize, &QMenu::triggered, this, &MainWindow::setTimelineToolbarIconSize);
     menu.exec(m_timelineToolBar->mapToGlobal(pos));
     contextSize->deleteLater();
 }
 
 void MainWindow::setTimelineToolbarIconSize(QAction *a)
 {
     if (!a) {
         return;
     }
     int size = a->data().toInt();
     m_timelineToolBar->setIconDimensions(size);
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup mainConfig(config, QStringLiteral("MainWindow"));
     KConfigGroup tbGroup(&mainConfig, QStringLiteral("Toolbar timelineToolBar"));
     m_timelineToolBar->saveSettings(tbGroup);
 }
 
 void MainWindow::slotManageCache()
 {
     QDialog d(this);
     d.setWindowTitle(i18n("Manage Cache Data"));
     auto *lay = new QVBoxLayout;
     TemporaryData tmp(pCore->currentDoc(), false, this);
     connect(&tmp, &TemporaryData::disableProxies, this, &MainWindow::slotDisableProxies);
     // TODO refac
     /*
     connect(&tmp, SIGNAL(disablePreview()), pCore->projectManager()->currentTimeline(), SLOT(invalidateRange()));
     */
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
     lay->addWidget(&tmp);
     lay->addWidget(buttonBox);
     d.setLayout(lay);
     d.exec();
 }
 
 void MainWindow::slotUpdateCompositing(QAction *compose)
 {
     int mode = compose->data().toInt();
     getMainTimeline()->controller()->switchCompositing(mode);
     if (m_renderWidget) {
         m_renderWidget->errorMessage(RenderWidget::CompositeError, mode == 1 ? i18n("Rendering using low quality track compositing") : QString());
     }
     pCore->currentDoc()->setModified();
 }
 
 void MainWindow::slotUpdateCompositeAction(int mode)
 {
     QList<QAction *> actions = m_compositeAction->actions();
     for (int i = 0; i < actions.count(); i++) {
         if (actions.at(i)->data().toInt() == mode) {
             m_compositeAction->setCurrentAction(actions.at(i));
             break;
         }
     }
     if (m_renderWidget) {
         m_renderWidget->errorMessage(RenderWidget::CompositeError, mode == 1 ? i18n("Rendering using low quality track compositing") : QString());
     }
 }
 
 void MainWindow::showMenuBar(bool show)
 {
     if (!show) {
         KMessageBox::information(this, i18n("This will hide the menu bar completely. You can show it again by typing Ctrl+M."), i18n("Hide menu bar"),
                                  QStringLiteral("show-menubar-warning"));
     }
     menuBar()->setVisible(show);
 }
 
 void MainWindow::forceIconSet(bool force)
 {
     KdenliveSettings::setForce_breeze(force);
     if (force) {
         // Check current color theme
         QColor background = qApp->palette().window().color();
         bool useDarkIcons = background.value() < 100;
         KdenliveSettings::setUse_dark_breeze(useDarkIcons);
     }
     if (KMessageBox::warningContinueCancel(this, i18n("Kdenlive needs to be restarted to apply the icon theme change. Restart now?")) ==
         KMessageBox::Continue) {
         slotRestart();
     }
 }
 
 void MainWindow::slotSwitchTrimMode()
 {
     // TODO refac
     /*
     if (pCore->projectManager()->currentTimeline()) {
         pCore->projectManager()->currentTimeline()->projectView()->switchTrimMode();
     }
     */
 }
 
 void MainWindow::setTrimMode(const QString &mode){
     Q_UNUSED(mode)
     // TODO refac
     /*
     if (pCore->projectManager()->currentTimeline()) {
         m_trimLabel->setText(mode);
         m_trimLabel->setVisible(!mode.isEmpty());
     }
     */
 }
 
 TimelineWidget *MainWindow::getMainTimeline() const
 {
     return m_timelineTabs->getMainTimeline();
 }
 
 TimelineWidget *MainWindow::getCurrentTimeline() const
 {
     return m_timelineTabs->getCurrentTimeline();
 }
 
 void MainWindow::resetTimelineTracks()
 {
     TimelineWidget *current = getCurrentTimeline();
     if (current) {
         current->controller()->resetTrackHeight();
     }
 }
 
 void MainWindow::slotEditItemSpeed()
 {
     TimelineWidget *current = getCurrentTimeline();
     if (current) {
         current->controller()->changeItemSpeed(-1, -1);
     }
 }
 
 void MainWindow::slotSwitchTimelineZone(bool active)
 {
     pCore->currentDoc()->setDocumentProperty(QStringLiteral("enableTimelineZone"), active ? QStringLiteral("1") : QStringLiteral("0"));
     getCurrentTimeline()->controller()->useRulerChanged();
     QSignalBlocker blocker(m_useTimelineZone);
     m_useTimelineZone->setActive(active);
 }
 
 void MainWindow::slotGrabItem()
 {
     getCurrentTimeline()->controller()->grabCurrent();
 }
 
 void MainWindow::slotCollapse()
 {
     if ((QApplication::focusWidget() != nullptr) && (QApplication::focusWidget()->parentWidget() != nullptr) &&
         QApplication::focusWidget()->parentWidget() == pCore->bin()) {
         // Bin expand/collapse?
 
     } else {
         QWidget *widget = QApplication::focusWidget();
         while ((widget != nullptr) && widget != this) {
             if (widget == m_effectStackDock) {
                 m_assetPanel->collapseCurrentEffect();
                 return;
             }
             widget = widget->parentWidget();
         }
 
         // Collapse / expand track
         getMainTimeline()->controller()->collapseActiveTrack();
     }
 }
 
 
 void MainWindow::slotExpandClip()
 {
     getCurrentTimeline()->controller()->expandActiveClip();
 }
 
 
 #ifdef DEBUG_MAINW
 #undef DEBUG_MAINW
 #endif
diff --git a/src/mltcontroller/clippropertiescontroller.cpp b/src/mltcontroller/clippropertiescontroller.cpp
index 3003c7b14..3d1cfc32d 100644
--- a/src/mltcontroller/clippropertiescontroller.cpp
+++ b/src/mltcontroller/clippropertiescontroller.cpp
@@ -1,1386 +1,1366 @@
 /*
 Copyright (C) 2015  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 "clippropertiescontroller.h"
 #include "bin/model/markerlistmodel.hpp"
 #include "clipcontroller.h"
 #include "core.h"
 #include "dialogs/profilesdialog.h"
 #include "doc/kdenlivedoc.h"
 #include "kdenlivesettings.h"
 #include "profiles/profilerepository.hpp"
 #include "project/projectmanager.h"
 #include "timecodedisplay.h"
 #include <audio/audioStreamInfo.h>
 #include "widgets/choosecolorwidget.h"
 
 #include <KDualAction>
 #include <KLocalizedString>
 
 #ifdef KF5_USE_FILEMETADATA
 #include <KFileMetaData/ExtractionResult>
 #include <KFileMetaData/Extractor>
 #include <KFileMetaData/ExtractorCollection>
 #include <KFileMetaData/PropertyInfo>
 #endif
 
 #include <KIO/Global>
 
 #include "kdenlive_debug.h"
 #include <KMessageBox>
 #include <QCheckBox>
 #include <QClipboard>
 #include <QComboBox>
 #include <QDesktopServices>
 #include <QDoubleSpinBox>
 #include <QFile>
 #include <QFileDialog>
 #include <QFontDatabase>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QMenu>
 #include <QMimeData>
 #include <QMimeDatabase>
 #include <QProcess>
 #include <QScrollArea>
 #include <QTextEdit>
 #include <QToolBar>
 #include <QUrl>
 #include <QVBoxLayout>
 
 AnalysisTree::AnalysisTree(QWidget *parent)
     : QTreeWidget(parent)
 {
     setRootIsDecorated(false);
     setColumnCount(2);
     setAlternatingRowColors(true);
     setHeaderHidden(true);
     setDragEnabled(true);
 }
 
 // virtual
 QMimeData *AnalysisTree::mimeData(const QList<QTreeWidgetItem *> list) const
 {
     QString mimeData;
     for (QTreeWidgetItem *item : list) {
         if ((item->flags() & Qt::ItemIsDragEnabled) != 0) {
             mimeData.append(item->text(1));
         }
     }
     auto *mime = new QMimeData;
     mime->setData(QStringLiteral("kdenlive/geometry"), mimeData.toUtf8());
     return mime;
 }
 
 #ifdef KF5_USE_FILEMETADATA
 class ExtractionResult : public KFileMetaData::ExtractionResult
 {
 public:
     ExtractionResult(const QString &filename, const QString &mimetype, QTreeWidget *tree)
         : KFileMetaData::ExtractionResult(filename, mimetype, KFileMetaData::ExtractionResult::ExtractMetaData)
         , m_tree(tree)
     {
     }
 
     void append(const QString & /*text*/) override {}
 
     void addType(KFileMetaData::Type::Type /*type*/) override {}
 
     void add(KFileMetaData::Property::Property property, const QVariant &value) override
     {
         bool decode = false;
         switch (property) {
         case KFileMetaData::Property::ImageMake:
         case KFileMetaData::Property::ImageModel:
         case KFileMetaData::Property::ImageDateTime:
         case KFileMetaData::Property::BitRate:
         case KFileMetaData::Property::TrackNumber:
         case KFileMetaData::Property::ReleaseYear:
         case KFileMetaData::Property::Composer:
         case KFileMetaData::Property::Genre:
         case KFileMetaData::Property::Artist:
         case KFileMetaData::Property::Album:
         case KFileMetaData::Property::Title:
         case KFileMetaData::Property::Comment:
         case KFileMetaData::Property::Copyright:
         case KFileMetaData::Property::PhotoFocalLength:
         case KFileMetaData::Property::PhotoExposureTime:
         case KFileMetaData::Property::PhotoFNumber:
         case KFileMetaData::Property::PhotoApertureValue:
         case KFileMetaData::Property::PhotoWhiteBalance:
         case KFileMetaData::Property::PhotoGpsLatitude:
         case KFileMetaData::Property::PhotoGpsLongitude:
             decode = true;
             break;
         default:
             break;
         }
         if (decode) {
             KFileMetaData::PropertyInfo info(property);
             if (info.valueType() == QVariant::DateTime) {
                 new QTreeWidgetItem(m_tree, QStringList() << info.displayName() << value.toDateTime().toString(Qt::DefaultLocaleShortDate));
             } else if (info.valueType() == QVariant::Int) {
                 int val = value.toInt();
                 if (property == KFileMetaData::Property::BitRate) {
                     // Adjust unit for bitrate
                     new QTreeWidgetItem(m_tree, QStringList() << info.displayName()
                                                               << QString::number(val / 1000) + QLatin1Char(' ') + i18nc("Kilobytes per seconds", "kb/s"));
                 } else {
                     new QTreeWidgetItem(m_tree, QStringList() << info.displayName() << QString::number(val));
                 }
             } else if (info.valueType() == QVariant::Double) {
                 new QTreeWidgetItem(m_tree, QStringList() << info.displayName() << QString::number(value.toDouble()));
             } else {
                 new QTreeWidgetItem(m_tree, QStringList() << info.displayName() << value.toString());
             }
         }
     }
 
 private:
     QTreeWidget *m_tree;
 };
 #endif
 
 ClipPropertiesController::ClipPropertiesController(ClipController *controller, QWidget *parent)
     : QWidget(parent)
     , m_controller(controller)
     , m_tc(Timecode(Timecode::HH_MM_SS_HH, pCore->getCurrentFps()))
     , m_id(controller->binId())
     , m_type(controller->clipType())
     , m_properties(new Mlt::Properties(controller->properties()))
     , m_textEdit(nullptr)
 {
     m_controller->mirrorOriginalProperties(m_sourceProperties);
     setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
     setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
     auto *lay = new QVBoxLayout;
     lay->setContentsMargins(0, 0, 0, 0);
     m_clipLabel = new QLabel(controller->clipName());
     lay->addWidget(m_clipLabel);
     m_tabWidget = new QTabWidget(this);
     lay->addWidget(m_tabWidget);
     setLayout(lay);
     m_tabWidget->setDocumentMode(true);
     m_tabWidget->setTabPosition(QTabWidget::East);
     auto *forcePage = new QScrollArea(this);
     m_propertiesPage = new QWidget(this);
     m_markersPage = new QWidget(this);
     m_metaPage = new QWidget(this);
     m_analysisPage = new QWidget(this);
 
     // Clip properties
     auto *propsBox = new QVBoxLayout;
     m_propertiesTree = new QTreeWidget(this);
     m_propertiesTree->setRootIsDecorated(false);
     m_propertiesTree->setColumnCount(2);
     m_propertiesTree->setAlternatingRowColors(true);
     m_propertiesTree->sortByColumn(0, Qt::AscendingOrder);
     m_propertiesTree->setHeaderHidden(true);
     propsBox->addWidget(m_propertiesTree);
     fillProperties();
     m_propertiesPage->setLayout(propsBox);
 
     // Clip markers
     auto *mBox = new QVBoxLayout;
     m_markerTree = new QTreeView;
     m_markerTree->setRootIsDecorated(false);
     m_markerTree->setAlternatingRowColors(true);
     m_markerTree->setHeaderHidden(true);
     m_markerTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_markerTree->setModel(controller->getMarkerModel().get());
     mBox->addWidget(m_markerTree);
     auto *bar = new QToolBar;
     bar->addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Add marker"), this, SLOT(slotAddMarker()));
     bar->addAction(QIcon::fromTheme(QStringLiteral("trash-empty")), i18n("Delete marker"), this, SLOT(slotDeleteMarker()));
     bar->addAction(QIcon::fromTheme(QStringLiteral("document-edit")), i18n("Edit marker"), this, SLOT(slotEditMarker()));
     bar->addAction(QIcon::fromTheme(QStringLiteral("document-save-as")), i18n("Export markers"), this, SLOT(slotSaveMarkers()));
     bar->addAction(QIcon::fromTheme(QStringLiteral("document-open")), i18n("Import markers"), this, SLOT(slotLoadMarkers()));
     mBox->addWidget(bar);
 
     m_markersPage->setLayout(mBox);
     connect(m_markerTree, &QAbstractItemView::doubleClicked, this, &ClipPropertiesController::slotSeekToMarker);
 
     // metadata
     auto *m2Box = new QVBoxLayout;
     auto *metaTree = new QTreeWidget;
     metaTree->setRootIsDecorated(true);
     metaTree->setColumnCount(2);
     metaTree->setAlternatingRowColors(true);
     metaTree->setHeaderHidden(true);
     m2Box->addWidget(metaTree);
     slotFillMeta(metaTree);
     m_metaPage->setLayout(m2Box);
 
     // Clip analysis
     auto *aBox = new QVBoxLayout;
     m_analysisTree = new AnalysisTree(this);
     aBox->addWidget(new QLabel(i18n("Analysis data")));
     aBox->addWidget(m_analysisTree);
     auto *bar2 = new QToolBar;
     bar2->addAction(QIcon::fromTheme(QStringLiteral("trash-empty")), i18n("Delete analysis"), this, SLOT(slotDeleteAnalysis()));
     bar2->addAction(QIcon::fromTheme(QStringLiteral("document-save-as")), i18n("Export analysis"), this, SLOT(slotSaveAnalysis()));
     bar2->addAction(QIcon::fromTheme(QStringLiteral("document-open")), i18n("Import analysis"), this, SLOT(slotLoadAnalysis()));
     aBox->addWidget(bar2);
 
     slotFillAnalysisData();
     m_analysisPage->setLayout(aBox);
 
     // Force properties
     auto *vbox = new QVBoxLayout;
     vbox->setSpacing(0);
     if (m_type == ClipType::Text || m_type == ClipType::SlideShow || m_type == ClipType::TextTemplate) {
         QPushButton *editButton = new QPushButton(i18n("Edit Clip"), this);
         connect(editButton, &QAbstractButton::clicked, this, &ClipPropertiesController::editClip);
         vbox->addWidget(editButton);
     }
     if (m_type == ClipType::Color || m_type == ClipType::Image || m_type == ClipType::AV || m_type == ClipType::Video || m_type == ClipType::TextTemplate) {
         // Edit duration widget
         m_originalProperties.insert(QStringLiteral("out"), m_properties->get("out"));
         int kdenlive_length = m_properties->time_to_frames(m_properties->get("kdenlive:duration"));
         if (kdenlive_length > 0) {
             m_originalProperties.insert(QStringLiteral("kdenlive:duration"), m_properties->get("kdenlive:duration"));
         }
         m_originalProperties.insert(QStringLiteral("length"), m_properties->get("length"));
         auto *hlay = new QHBoxLayout;
         QCheckBox *box = new QCheckBox(i18n("Duration"), this);
         box->setObjectName(QStringLiteral("force_duration"));
         hlay->addWidget(box);
         auto *timePos = new TimecodeDisplay(m_tc, this);
         timePos->setObjectName(QStringLiteral("force_duration_value"));
         timePos->setValue(kdenlive_length > 0 ? kdenlive_length : m_properties->get_int("length"));
         int original_length = m_properties->get_int("kdenlive:original_length");
         if (original_length > 0) {
             box->setChecked(true);
         } else {
             timePos->setEnabled(false);
         }
         hlay->addWidget(timePos);
         vbox->addLayout(hlay);
         connect(box, &QAbstractButton::toggled, timePos, &QWidget::setEnabled);
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         connect(timePos, &TimecodeDisplay::timeCodeEditingFinished, this, &ClipPropertiesController::slotDurationChanged);
         connect(this, &ClipPropertiesController::updateTimeCodeFormat, timePos, &TimecodeDisplay::slotUpdateTimeCodeFormat);
         connect(this, SIGNAL(modified(int)), timePos, SLOT(setValue(int)));
         // connect(this, static_cast<void(ClipPropertiesController::*)(int)>(&ClipPropertiesController::modified), timePos, &TimecodeDisplay::setValue);
     }
     if (m_type == ClipType::TextTemplate) {
         // Edit text widget
         QString currentText = m_properties->get("templatetext");
         m_originalProperties.insert(QStringLiteral("templatetext"), currentText);
         m_textEdit = new QTextEdit(this);
         m_textEdit->setAcceptRichText(false);
         m_textEdit->setPlainText(currentText);
         m_textEdit->setPlaceholderText(i18n("Enter template text here"));
         vbox->addWidget(m_textEdit);
         QPushButton *button = new QPushButton(i18n("Apply"), this);
         vbox->addWidget(button);
         connect(button, &QPushButton::clicked, this, &ClipPropertiesController::slotTextChanged);
     } else if (m_type == ClipType::Color) {
         // Edit color widget
         m_originalProperties.insert(QStringLiteral("resource"), m_properties->get("resource"));
         mlt_color color = m_properties->get_color("resource");
         ChooseColorWidget *choosecolor = new ChooseColorWidget(i18n("Color"), QColor::fromRgb(color.r, color.g, color.b).name(), "", false, this);
         vbox->addWidget(choosecolor);
         // connect(choosecolor, SIGNAL(displayMessage(QString,int)), this, SIGNAL(displayMessage(QString,int)));
         connect(choosecolor, &ChooseColorWidget::modified, this, &ClipPropertiesController::slotColorModified);
         connect(this, static_cast<void (ClipPropertiesController::*)(const QColor &)>(&ClipPropertiesController::modified), choosecolor,
                 &ChooseColorWidget::slotColorModified);
     }
     if (m_type == ClipType::AV || m_type == ClipType::Video || m_type == ClipType::Image) {
         // Aspect ratio
         int force_ar_num = m_properties->get_int("force_aspect_num");
         int force_ar_den = m_properties->get_int("force_aspect_den");
         m_originalProperties.insert(QStringLiteral("force_aspect_den"), (force_ar_den == 0) ? QString() : QString::number(force_ar_den));
         m_originalProperties.insert(QStringLiteral("force_aspect_num"), (force_ar_num == 0) ? QString() : QString::number(force_ar_num));
         auto *hlay = new QHBoxLayout;
         QCheckBox *box = new QCheckBox(i18n("Aspect ratio"), this);
         box->setObjectName(QStringLiteral("force_ar"));
         vbox->addWidget(box);
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         auto *spin1 = new QSpinBox(this);
         spin1->setMaximum(8000);
         spin1->setObjectName(QStringLiteral("force_aspect_num_value"));
         hlay->addWidget(spin1);
         hlay->addWidget(new QLabel(QStringLiteral(":")));
         auto *spin2 = new QSpinBox(this);
         spin2->setMinimum(1);
         spin2->setMaximum(8000);
         spin2->setObjectName(QStringLiteral("force_aspect_den_value"));
         hlay->addWidget(spin2);
         if (force_ar_num == 0) {
             // use current ratio
             int num = m_properties->get_int("meta.media.sample_aspect_num");
             int den = m_properties->get_int("meta.media.sample_aspect_den");
             if (den == 0) {
                 num = 1;
                 den = 1;
             }
             spin1->setEnabled(false);
             spin2->setEnabled(false);
             spin1->setValue(num);
             spin2->setValue(den);
         } else {
             box->setChecked(true);
             spin1->setEnabled(true);
             spin2->setEnabled(true);
             spin1->setValue(force_ar_num);
             spin2->setValue(force_ar_den);
         }
         connect(spin2, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &ClipPropertiesController::slotAspectValueChanged);
         connect(spin1, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &ClipPropertiesController::slotAspectValueChanged);
         connect(box, &QAbstractButton::toggled, spin1, &QWidget::setEnabled);
         connect(box, &QAbstractButton::toggled, spin2, &QWidget::setEnabled);
         vbox->addLayout(hlay);
 
         // Proxy
         QString proxy = m_properties->get("kdenlive:proxy");
         m_originalProperties.insert(QStringLiteral("kdenlive:proxy"), proxy);
         hlay = new QHBoxLayout;
         auto *bg = new QGroupBox(this);
         bg->setCheckable(false);
         bg->setFlat(true);
         auto *groupLay = new QHBoxLayout;
         groupLay->setContentsMargins(0, 0, 0, 0);
         auto *pbox = new QCheckBox(i18n("Proxy clip"), this);
         pbox->setTristate(true);
         // Proxy codec label
         QLabel *lab = new QLabel(this);
         pbox->setObjectName(QStringLiteral("kdenlive:proxy"));
         bool hasProxy = proxy.length() > 2;
         if (hasProxy) {
             bg->setToolTip(proxy);
             bool proxyReady = (QFileInfo(proxy).fileName() == QFileInfo(m_properties->get("resource")).fileName());
             if (proxyReady) {
                 pbox->setCheckState(Qt::Checked);
                 lab->setText(m_properties->get(QString("meta.media.%1.codec.name").arg(m_properties->get_int("video_index")).toUtf8().constData()));
             } else {
                 pbox->setCheckState(Qt::PartiallyChecked);
             }
         } else {
             pbox->setCheckState(Qt::Unchecked);
         }
         pbox->setEnabled(pCore->projectManager()->current()->getDocumentProperty(QStringLiteral("enableproxy")).toInt() != 0);
         connect(pbox, &QCheckBox::stateChanged, [this, pbox](int state) {
             emit requestProxy(state == Qt::PartiallyChecked);
             if (state == Qt::Checked) {
                 QSignalBlocker bk(pbox);
                 pbox->setCheckState(Qt::Unchecked);
             }
         });
         connect(this, &ClipPropertiesController::enableProxy, pbox, &QCheckBox::setEnabled);
         connect(this, &ClipPropertiesController::proxyModified, [this, pbox, bg, lab](const QString &pxy) {
             bool hasProxyClip = pxy.length() > 2;
             QSignalBlocker bk(pbox);
             pbox->setCheckState(hasProxyClip ? Qt::Checked : Qt::Unchecked);
             bg->setEnabled(pbox->isChecked());
             bg->setToolTip(pxy);
             lab->setText(hasProxyClip ? m_properties->get(QString("meta.media.%1.codec.name").arg(m_properties->get_int("video_index")).toUtf8().constData())
                                       : QString());
         });
         hlay->addWidget(pbox);
         bg->setEnabled(pbox->checkState() == Qt::Checked);
 
         groupLay->addWidget(lab);
 
         // Delete button
         auto *tb = new QToolButton(this);
         tb->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
         tb->setAutoRaise(true);
         connect(tb, &QToolButton::clicked, [this, proxy]() { emit deleteProxy(); });
         tb->setToolTip(i18n("Delete proxy file"));
         groupLay->addWidget(tb);
         // Folder button
         tb = new QToolButton(this);
         auto *pMenu = new QMenu(this);
         tb->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-menu")));
         tb->setToolTip(i18n("Proxy options"));
         tb->setMenu(pMenu);
         tb->setAutoRaise(true);
         tb->setPopupMode(QToolButton::InstantPopup);
 
         QAction *ac = new QAction(QIcon::fromTheme(QStringLiteral("document-open")), i18n("Open folder"), this);
         connect(ac, &QAction::triggered, [this]() {
             QString pxy = m_properties->get("kdenlive:proxy");
             QDesktopServices::openUrl(QUrl::fromLocalFile(QFileInfo(pxy).path()));
         });
         pMenu->addAction(ac);
         ac = new QAction(QIcon::fromTheme(QStringLiteral("media-playback-start")), i18n("Play proxy clip"), this);
         connect(ac, &QAction::triggered, [this]() {
             QString pxy = m_properties->get("kdenlive:proxy");
             QDesktopServices::openUrl(QUrl::fromLocalFile(pxy));
         });
         pMenu->addAction(ac);
         ac = new QAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18n("Copy file location to clipboard"), this);
         connect(ac, &QAction::triggered, [this]() {
             QString pxy = m_properties->get("kdenlive:proxy");
             QGuiApplication::clipboard()->setText(pxy);
         });
         pMenu->addAction(ac);
         groupLay->addWidget(tb);
         bg->setLayout(groupLay);
         hlay->addWidget(bg);
         vbox->addLayout(hlay);
     }
 
     if (m_type == ClipType::AV || m_type == ClipType::Video) {
         QLocale locale;
         locale.setNumberOptions(QLocale::OmitGroupSeparator);
 
         // Fps
         QString force_fps = m_properties->get("force_fps");
         m_originalProperties.insert(QStringLiteral("force_fps"), force_fps.isEmpty() ? QStringLiteral("-") : force_fps);
         auto *hlay = new QHBoxLayout;
         QCheckBox *box = new QCheckBox(i18n("Frame rate"), this);
         box->setObjectName(QStringLiteral("force_fps"));
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         auto *spin = new QDoubleSpinBox(this);
         spin->setMaximum(1000);
         connect(spin, SIGNAL(valueChanged(double)), this, SLOT(slotValueChanged(double)));
         // connect(spin, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &ClipPropertiesController::slotValueChanged);
         spin->setObjectName(QStringLiteral("force_fps_value"));
         if (force_fps.isEmpty()) {
             spin->setValue(controller->originalFps());
         } else {
             spin->setValue(locale.toDouble(force_fps));
         }
         connect(box, &QAbstractButton::toggled, spin, &QWidget::setEnabled);
         box->setChecked(!force_fps.isEmpty());
         spin->setEnabled(!force_fps.isEmpty());
         hlay->addWidget(box);
         hlay->addWidget(spin);
         vbox->addLayout(hlay);
 
         // Scanning
         QString force_prog = m_properties->get("force_progressive");
         m_originalProperties.insert(QStringLiteral("force_progressive"), force_prog.isEmpty() ? QStringLiteral("-") : force_prog);
         hlay = new QHBoxLayout;
         box = new QCheckBox(i18n("Scanning"), this);
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         box->setObjectName(QStringLiteral("force_progressive"));
         auto *combo = new QComboBox(this);
         combo->addItem(i18n("Interlaced"), 0);
         combo->addItem(i18n("Progressive"), 1);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         connect(combo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ClipPropertiesController::slotComboValueChanged);
-#else
-        connect(combo, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this, &ClipPropertiesController::slotComboValueChanged);
-#endif
         combo->setObjectName(QStringLiteral("force_progressive_value"));
         if (!force_prog.isEmpty()) {
             combo->setCurrentIndex(force_prog.toInt());
         }
         connect(box, &QAbstractButton::toggled, combo, &QWidget::setEnabled);
         box->setChecked(!force_prog.isEmpty());
         combo->setEnabled(!force_prog.isEmpty());
         hlay->addWidget(box);
         hlay->addWidget(combo);
         vbox->addLayout(hlay);
 
         // Field order
         QString force_tff = m_properties->get("force_tff");
         m_originalProperties.insert(QStringLiteral("force_tff"), force_tff.isEmpty() ? QStringLiteral("-") : force_tff);
         hlay = new QHBoxLayout;
         box = new QCheckBox(i18n("Field order"), this);
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         box->setObjectName(QStringLiteral("force_tff"));
         combo = new QComboBox(this);
         combo->addItem(i18n("Bottom first"), 0);
         combo->addItem(i18n("Top first"), 1);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         connect(combo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ClipPropertiesController::slotComboValueChanged);
-#else
-        connect(combo, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this, &ClipPropertiesController::slotComboValueChanged);
-#endif
         combo->setObjectName(QStringLiteral("force_tff_value"));
         if (!force_tff.isEmpty()) {
             combo->setCurrentIndex(force_tff.toInt());
         }
         connect(box, &QAbstractButton::toggled, combo, &QWidget::setEnabled);
         box->setChecked(!force_tff.isEmpty());
         combo->setEnabled(!force_tff.isEmpty());
         hlay->addWidget(box);
         hlay->addWidget(combo);
         vbox->addLayout(hlay);
 
         // Autorotate
         QString autorotate = m_properties->get("autorotate");
         m_originalProperties.insert(QStringLiteral("autorotate"), autorotate);
         hlay = new QHBoxLayout;
         box = new QCheckBox(i18n("Disable autorotate"), this);
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         box->setObjectName(QStringLiteral("autorotate"));
         box->setChecked(autorotate == QLatin1String("0"));
         hlay->addWidget(box);
         vbox->addLayout(hlay);
 
         // Decoding threads
         QString threads = m_properties->get("threads");
         m_originalProperties.insert(QStringLiteral("threads"), threads);
         hlay = new QHBoxLayout;
         hlay->addWidget(new QLabel(i18n("Threads")));
         auto *spinI = new QSpinBox(this);
         spinI->setMaximum(4);
         spinI->setMinimum(1);
         spinI->setObjectName(QStringLiteral("threads_value"));
         if (!threads.isEmpty()) {
             spinI->setValue(threads.toInt());
         } else {
             spinI->setValue(1);
         }
         connect(spinI, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
                 static_cast<void (ClipPropertiesController::*)(int)>(&ClipPropertiesController::slotValueChanged));
         hlay->addWidget(spinI);
         vbox->addLayout(hlay);
 
         // Video index
         if (!m_videoStreams.isEmpty()) {
             QString vix = m_sourceProperties.get("video_index");
             m_originalProperties.insert(QStringLiteral("video_index"), vix);
             hlay = new QHBoxLayout;
 
             KDualAction *ac = new KDualAction(i18n("Disable video"), i18n("Enable video"), this);
             ac->setInactiveIcon(QIcon::fromTheme(QStringLiteral("kdenlive-show-video")));
             ac->setActiveIcon(QIcon::fromTheme(QStringLiteral("kdenlive-hide-video")));
             auto *tbv = new QToolButton(this);
             tbv->setToolButtonStyle(Qt::ToolButtonIconOnly);
             tbv->setDefaultAction(ac);
             tbv->setAutoRaise(true);
             hlay->addWidget(tbv);
             hlay->addWidget(new QLabel(i18n("Video stream")));
             auto *videoStream = new QComboBox(this);
             int ix = 1;
             for (int stream : m_videoStreams) {
                 videoStream->addItem(i18n("Video stream %1", ix), stream);
                 ix++;
             }
             if (!vix.isEmpty() && vix.toInt() > -1) {
                 videoStream->setCurrentIndex(videoStream->findData(QVariant(vix)));
             }
             ac->setActive(vix.toInt() == -1);
             videoStream->setEnabled(vix.toInt() > -1);
             videoStream->setVisible(m_videoStreams.size() > 1);
             connect(ac, &KDualAction::activeChanged, [this, videoStream](bool activated) {
                 QMap<QString, QString> properties;
                 int vindx = -1;
                 if (activated) {
                     videoStream->setEnabled(false);
                 } else {
                     videoStream->setEnabled(true);
                     vindx = videoStream->currentData().toInt();
                 }
                 properties.insert(QStringLiteral("video_index"), QString::number(vindx));
                 properties.insert(QStringLiteral("set.test_image"), vindx > -1 ? QStringLiteral("0") : QStringLiteral("1"));
                 emit updateClipProperties(m_id, m_originalProperties, properties);
                 m_originalProperties = properties;
             });
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
             QObject::connect(videoStream, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), [this, videoStream]() {
-#else
-            QObject::connect(videoStream, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , [this, videoStream]() {
-#endif
                 QMap<QString, QString> properties;
                 properties.insert(QStringLiteral("video_index"), QString::number(videoStream->currentData().toInt()));
                 emit updateClipProperties(m_id, m_originalProperties, properties);
                 m_originalProperties = properties;
             });
             hlay->addWidget(videoStream);
             vbox->addLayout(hlay);
         }
 
         // Audio index
         QMap<int, QString> audioStreamsInfo;
         if (m_controller->audioInfo()) {
             audioStreamsInfo = m_controller->audioInfo()->streamInfo(m_sourceProperties);
         }
         if (!audioStreamsInfo.isEmpty()) {
             QString vix = m_sourceProperties.get("audio_index");
             m_originalProperties.insert(QStringLiteral("audio_index"), vix);
             hlay = new QHBoxLayout;
 
             KDualAction *ac = new KDualAction(i18n("Disable audio"), i18n("Enable audio"), this);
             ac->setInactiveIcon(QIcon::fromTheme(QStringLiteral("kdenlive-show-audio")));
             ac->setActiveIcon(QIcon::fromTheme(QStringLiteral("kdenlive-hide-audio")));
             auto *tbv = new QToolButton(this);
             tbv->setToolButtonStyle(Qt::ToolButtonIconOnly);
             tbv->setDefaultAction(ac);
             tbv->setAutoRaise(true);
             hlay->addWidget(tbv);
             hlay->addWidget(new QLabel(i18n("Audio stream")));
             auto *audioStream = new QComboBox(this);
             QMapIterator<int, QString> i(audioStreamsInfo);
             while (i.hasNext()) {
                 i.next();
                 audioStream->addItem(QString("%1: %2").arg(i.key()).arg(i.value()), i.key());
             }
             if (!vix.isEmpty() && vix.toInt() > -1) {
                 audioStream->setCurrentIndex(audioStream->findData(QVariant(vix)));
             }
             ac->setActive(vix.toInt() == -1);
             audioStream->setEnabled(vix.toInt() > -1);
             audioStream->setVisible(audioStreamsInfo.size() > 0);
             connect(ac, &KDualAction::activeChanged, [this, audioStream](bool activated) {
                 QMap<QString, QString> properties;
                 int vindx = -1;
                 if (activated) {
                     audioStream->setEnabled(false);
                 } else {
                     audioStream->setEnabled(true);
                     vindx = audioStream->currentData().toInt();
                 }
                 properties.insert(QStringLiteral("audio_index"), QString::number(vindx));
                 properties.insert(QStringLiteral("set.test_audio"), vindx > -1 ? QStringLiteral("0") : QStringLiteral("1"));
                 emit updateClipProperties(m_id, m_originalProperties, properties);
                 m_originalProperties = properties;
             });
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
             QObject::connect(audioStream, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), [this, audioStream]() {
-#else
-            QObject::connect(audioStream, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , [this, audioStream]() {
-#endif
                 QMap<QString, QString> properties;
                 properties.insert(QStringLiteral("audio_index"), QString::number(audioStream->currentData().toInt()));
                 emit updateClipProperties(m_id, m_originalProperties, properties);
                 m_originalProperties = properties;
             });
             hlay->addWidget(audioStream);
             vbox->addLayout(hlay);
 
             // Audio sync
             hlay = new QHBoxLayout;
             hlay->addWidget(new QLabel(i18n("Audio sync")));
             auto *spinSync = new QSpinBox(this);
             spinSync->setSuffix(i18n("ms"));
             spinSync->setRange(-1000, 1000);
             spinSync->setValue(qRound(1000 * m_sourceProperties.get_double("video_delay")));
             spinSync->setObjectName(QStringLiteral("video_delay"));
             if (spinSync->value() != 0) {
                 m_originalProperties.insert(QStringLiteral("video_delay"), locale.toString(m_sourceProperties.get_double("video_delay")));
             }
             //QObject::connect(spinSync, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), [this, spinSync]() {
             QObject::connect(spinSync, &QSpinBox::editingFinished, [this, spinSync, locale]() {
                 QMap<QString, QString> properties;
                 properties.insert(QStringLiteral("video_delay"), locale.toString(spinSync->value() / 1000.));
                 emit updateClipProperties(m_id, m_originalProperties, properties);
                 m_originalProperties = properties;
             });
             hlay->addWidget(spinSync);
             vbox->addLayout(hlay);
         }
 
         // Colorspace
         hlay = new QHBoxLayout;
         box = new QCheckBox(i18n("Colorspace"), this);
         box->setObjectName(QStringLiteral("force_colorspace"));
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         combo = new QComboBox(this);
         combo->setObjectName(QStringLiteral("force_colorspace_value"));
         combo->addItem(ProfileRepository::getColorspaceDescription(601), 601);
         combo->addItem(ProfileRepository::getColorspaceDescription(709), 709);
         combo->addItem(ProfileRepository::getColorspaceDescription(240), 240);
         int force_colorspace = m_properties->get_int("force_colorspace");
         m_originalProperties.insert(QStringLiteral("force_colorspace"), force_colorspace == 0 ? QStringLiteral("-") : QString::number(force_colorspace));
         int colorspace = controller->videoCodecProperty(QStringLiteral("colorspace")).toInt();
         if (force_colorspace > 0) {
             box->setChecked(true);
             combo->setEnabled(true);
             combo->setCurrentIndex(combo->findData(force_colorspace));
         } else if (colorspace > 0) {
             combo->setEnabled(false);
             combo->setCurrentIndex(combo->findData(colorspace));
         } else {
             combo->setEnabled(false);
         }
         connect(box, &QAbstractButton::toggled, combo, &QWidget::setEnabled);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         connect(combo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ClipPropertiesController::slotComboValueChanged);
-#else
-        connect(combo, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this, &ClipPropertiesController::slotComboValueChanged);
-#endif
         hlay->addWidget(box);
         hlay->addWidget(combo);
         vbox->addLayout(hlay);
 
         // Full luma
         QString force_luma = m_properties->get("set.force_full_luma");
         m_originalProperties.insert(QStringLiteral("set.force_full_luma"), force_luma);
         hlay = new QHBoxLayout;
         box = new QCheckBox(i18n("Full luma range"), this);
         connect(box, &QCheckBox::stateChanged, this, &ClipPropertiesController::slotEnableForce);
         box->setObjectName(QStringLiteral("set.force_full_luma"));
         box->setChecked(!force_luma.isEmpty());
         hlay->addWidget(box);
         vbox->addLayout(hlay);
         hlay->addStretch(10);
     }
     QWidget *forceProp = new QWidget(this);
     forceProp->setLayout(vbox);
     forcePage->setWidget(forceProp);
     forcePage->setWidgetResizable(true);
     vbox->addStretch(10);
     m_tabWidget->addTab(m_propertiesPage, QString());
     m_tabWidget->addTab(forcePage, QString());
     m_tabWidget->addTab(m_markersPage, QString());
     m_tabWidget->addTab(m_metaPage, QString());
     m_tabWidget->addTab(m_analysisPage, QString());
     m_tabWidget->setTabIcon(0, QIcon::fromTheme(QStringLiteral("edit-find")));
     m_tabWidget->setTabToolTip(0, i18n("File info"));
     m_tabWidget->setTabIcon(1, QIcon::fromTheme(QStringLiteral("document-edit")));
     m_tabWidget->setTabToolTip(1, i18n("Properties"));
     m_tabWidget->setTabIcon(2, QIcon::fromTheme(QStringLiteral("bookmark-new")));
     m_tabWidget->setTabToolTip(2, i18n("Markers"));
     m_tabWidget->setTabIcon(3, QIcon::fromTheme(QStringLiteral("view-grid")));
     m_tabWidget->setTabToolTip(3, i18n("Metadata"));
     m_tabWidget->setTabIcon(4, QIcon::fromTheme(QStringLiteral("visibility")));
     m_tabWidget->setTabToolTip(4, i18n("Analysis"));
     m_tabWidget->setCurrentIndex(KdenliveSettings::properties_panel_page());
     if (m_type == ClipType::Color) {
         m_tabWidget->setTabEnabled(0, false);
     }
     connect(m_tabWidget, &QTabWidget::currentChanged, this, &ClipPropertiesController::updateTab);
 }
 
 ClipPropertiesController::~ClipPropertiesController() = default;
 
 void ClipPropertiesController::updateTab(int ix)
 {
     KdenliveSettings::setProperties_panel_page(ix);
 }
 
 void ClipPropertiesController::slotRefreshTimeCode()
 {
     emit updateTimeCodeFormat();
 }
 
 void ClipPropertiesController::slotReloadProperties()
 {
     mlt_color color;
     m_properties.reset(new Mlt::Properties(m_controller->properties()));
     m_clipLabel->setText(m_properties->get("kdenlive:clipname"));
     switch (m_type) {
     case ClipType::Color:
         m_originalProperties.insert(QStringLiteral("resource"), m_properties->get("resource"));
         m_originalProperties.insert(QStringLiteral("out"), m_properties->get("out"));
         m_originalProperties.insert(QStringLiteral("length"), m_properties->get("length"));
         emit modified(m_properties->get_int("length"));
         color = m_properties->get_color("resource");
         emit modified(QColor::fromRgb(color.r, color.g, color.b));
         break;
     case ClipType::TextTemplate:
         m_textEdit->setPlainText(m_properties->get("templatetext"));
         break;
     case ClipType::Image:
     case ClipType::AV:
     case ClipType::Video: {
         QString proxy = m_properties->get("kdenlive:proxy");
         if (proxy != m_originalProperties.value(QStringLiteral("kdenlive:proxy"))) {
             m_originalProperties.insert(QStringLiteral("kdenlive:proxy"), proxy);
             emit proxyModified(proxy);
         }
         break;
     }
     default:
         break;
     }
 }
 
 void ClipPropertiesController::slotColorModified(const QColor &newcolor)
 {
     QMap<QString, QString> properties;
     properties.insert(QStringLiteral("resource"), newcolor.name(QColor::HexArgb));
     QMap<QString, QString> oldProperties;
     oldProperties.insert(QStringLiteral("resource"), m_properties->get("resource"));
     emit updateClipProperties(m_id, oldProperties, properties);
 }
 
 void ClipPropertiesController::slotDurationChanged(int duration)
 {
     QMap<QString, QString> properties;
     // kdenlive_length is the default duration for image / title clips
     int kdenlive_length = m_properties->time_to_frames(m_properties->get("kdenlive:duration"));
     int current_length = m_properties->get_int("length");
     if (kdenlive_length > 0) {
         // special case, image/title clips store default duration in kdenlive:duration property
         properties.insert(QStringLiteral("kdenlive:duration"), m_properties->frames_to_time(duration));
         if (duration > current_length) {
             properties.insert(QStringLiteral("length"), m_properties->frames_to_time(duration));
             properties.insert(QStringLiteral("out"), m_properties->frames_to_time(duration - 1));
         }
     } else {
         properties.insert(QStringLiteral("length"), m_properties->frames_to_time(duration));
         properties.insert(QStringLiteral("out"), m_properties->frames_to_time(duration - 1));
     }
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
 
 void ClipPropertiesController::slotEnableForce(int state)
 {
     auto *box = qobject_cast<QCheckBox *>(sender());
     if (!box) {
         return;
     }
     QString param = box->objectName();
     QMap<QString, QString> properties;
     QLocale locale;
     locale.setNumberOptions(QLocale::OmitGroupSeparator);
     if (state == Qt::Unchecked) {
         // The force property was disable, remove it / reset default if necessary
         if (param == QLatin1String("force_duration")) {
             // special case, reset original duration
             auto *timePos = findChild<TimecodeDisplay *>(param + QStringLiteral("_value"));
             timePos->setValue(m_properties->get_int("kdenlive:original_length"));
             int original = m_properties->get_int("kdenlive:original_length");
             m_properties->set("kdenlive:original_length", (char *)nullptr);
             slotDurationChanged(original);
             return;
         }
         if (param == QLatin1String("kdenlive:transparency")) {
             properties.insert(param, QString());
         } else if (param == QLatin1String("force_ar")) {
             properties.insert(QStringLiteral("force_aspect_den"), QString());
             properties.insert(QStringLiteral("force_aspect_num"), QString());
             properties.insert(QStringLiteral("force_aspect_ratio"), QString());
         } else if (param == QLatin1String("autorotate")) {
             properties.insert(QStringLiteral("autorotate"), QString());
         } else {
             properties.insert(param, QString());
         }
     } else {
         // A force property was set
         if (param == QLatin1String("force_duration")) {
             int original_length = m_properties->get_int("kdenlive:original_length");
             if (original_length == 0) {
                 int kdenlive_length = m_properties->time_to_frames(m_properties->get("kdenlive:duration"));
                 m_properties->set("kdenlive:original_length", kdenlive_length > 0 ? m_properties->get("kdenlive:duration") : m_properties->get("length"));
             }
         } else if (param == QLatin1String("force_fps")) {
             auto *spin = findChild<QDoubleSpinBox *>(param + QStringLiteral("_value"));
             if (!spin) {
                 return;
             }
             properties.insert(param, locale.toString(spin->value()));
         } else if (param == QLatin1String("threads")) {
             auto *spin = findChild<QSpinBox *>(param + QStringLiteral("_value"));
             if (!spin) {
                 return;
             }
             properties.insert(param, QString::number(spin->value()));
         } else if (param == QLatin1String("force_colorspace") || param == QLatin1String("force_progressive") || param == QLatin1String("force_tff")) {
             auto *combo = findChild<QComboBox *>(param + QStringLiteral("_value"));
             if (!combo) {
                 return;
             }
             properties.insert(param, QString::number(combo->currentData().toInt()));
         } else if (param == QLatin1String("set.force_full_luma")) {
             properties.insert(param, QStringLiteral("1"));
         } else if (param == QLatin1String("autorotate")) {
             properties.insert(QStringLiteral("autorotate"), QStringLiteral("0"));
         } else if (param == QLatin1String("force_ar")) {
             auto *spin = findChild<QSpinBox *>(QStringLiteral("force_aspect_num_value"));
             auto *spin2 = findChild<QSpinBox *>(QStringLiteral("force_aspect_den_value"));
             if ((spin == nullptr) || (spin2 == nullptr)) {
                 return;
             }
             properties.insert(QStringLiteral("force_aspect_den"), QString::number(spin2->value()));
             properties.insert(QStringLiteral("force_aspect_num"), QString::number(spin->value()));
             properties.insert(QStringLiteral("force_aspect_ratio"), locale.toString((double)spin->value() / spin2->value()));
         }
     }
     if (properties.isEmpty()) {
         return;
     }
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
 
 void ClipPropertiesController::slotValueChanged(double value)
 {
     auto *box = qobject_cast<QDoubleSpinBox *>(sender());
     if (!box) {
         return;
     }
     QString param = box->objectName().section(QLatin1Char('_'), 0, -2);
     QMap<QString, QString> properties;
     QLocale locale;
     locale.setNumberOptions(QLocale::OmitGroupSeparator);
     properties.insert(param, locale.toString(value));
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
 
 void ClipPropertiesController::slotValueChanged(int value)
 {
     auto *box = qobject_cast<QSpinBox *>(sender());
     if (!box) {
         return;
     }
     QString param = box->objectName().section(QLatin1Char('_'), 0, -2);
     QMap<QString, QString> properties;
     properties.insert(param, QString::number(value));
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
 
 void ClipPropertiesController::slotAspectValueChanged(int)
 {
     auto *spin = findChild<QSpinBox *>(QStringLiteral("force_aspect_num_value"));
     auto *spin2 = findChild<QSpinBox *>(QStringLiteral("force_aspect_den_value"));
     if ((spin == nullptr) || (spin2 == nullptr)) {
         return;
     }
     QMap<QString, QString> properties;
     properties.insert(QStringLiteral("force_aspect_den"), QString::number(spin2->value()));
     properties.insert(QStringLiteral("force_aspect_num"), QString::number(spin->value()));
     QLocale locale;
     locale.setNumberOptions(QLocale::OmitGroupSeparator);
     properties.insert(QStringLiteral("force_aspect_ratio"), locale.toString((double)spin->value() / spin2->value()));
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
 
 void ClipPropertiesController::slotComboValueChanged()
 {
     auto *box = qobject_cast<QComboBox *>(sender());
     if (!box) {
         return;
     }
     QString param = box->objectName().section(QLatin1Char('_'), 0, -2);
     QMap<QString, QString> properties;
     properties.insert(param, QString::number(box->currentData().toInt()));
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
 
 void ClipPropertiesController::fillProperties()
 {
     m_clipProperties.clear();
     QList<QStringList> propertyMap;
 
     m_propertiesTree->setSortingEnabled(false);
 
 #ifdef KF5_USE_FILEMETADATA
     // Read File Metadata through KDE's metadata system
     KFileMetaData::ExtractorCollection metaDataCollection;
     QMimeDatabase mimeDatabase;
     QMimeType mimeType;
 
     mimeType = mimeDatabase.mimeTypeForFile(m_controller->clipUrl());
     for (KFileMetaData::Extractor *plugin : metaDataCollection.fetchExtractors(mimeType.name())) {
         ExtractionResult extractionResult(m_controller->clipUrl(), mimeType.name(), m_propertiesTree);
         plugin->extract(&extractionResult);
     }
 #endif
 
     // Get MLT's metadata
     if (m_type == ClipType::Image) {
         int width = m_sourceProperties.get_int("meta.media.width");
         int height = m_sourceProperties.get_int("meta.media.height");
         propertyMap.append(QStringList() << i18n("Image size") << QString::number(width) + QLatin1Char('x') + QString::number(height));
     }
     if (m_type == ClipType::AV || m_type == ClipType::Video || m_type == ClipType::Audio) {
         int vindex = m_sourceProperties.get_int("video_index");
         int default_audio = m_sourceProperties.get_int("audio_index");
 
         // Find maximum stream index values
         m_videoStreams.clear();
         int aStreams = m_sourceProperties.get_int("meta.media.nb_streams");
         for (int ix = 0; ix < aStreams; ++ix) {
             char property[200];
             snprintf(property, sizeof(property), "meta.media.%d.stream.type", ix);
             QString type = m_sourceProperties.get(property);
             if (type == QLatin1String("video")) {
                 m_videoStreams << ix;
             }
         }
         m_clipProperties.insert(QStringLiteral("default_video"), QString::number(vindex));
         m_clipProperties.insert(QStringLiteral("default_audio"), QString::number(default_audio));
 
         if (vindex > -1) {
             // We have a video stream
             QString codecInfo = QString("meta.media.%1.codec.").arg(vindex);
             QString streamInfo = QString("meta.media.%1.stream.").arg(vindex);
             QString property = codecInfo + QStringLiteral("long_name");
             QString codec = m_sourceProperties.get(property.toUtf8().constData());
             if (!codec.isEmpty()) {
                 propertyMap.append({i18n("Video codec"), codec});
             }
             int width = m_sourceProperties.get_int("meta.media.width");
             int height = m_sourceProperties.get_int("meta.media.height");
             propertyMap.append({i18n("Frame size"), QString::number(width) + QLatin1Char('x') + QString::number(height)});
 
             property = streamInfo + QStringLiteral("frame_rate");
             QString fpsValue = m_sourceProperties.get(property.toUtf8().constData());
             if (!fpsValue.isEmpty()) {
                 propertyMap.append({i18n("Frame rate"), fpsValue});
             } else {
                 int rate_den = m_sourceProperties.get_int("meta.media.frame_rate_den");
                 if (rate_den > 0) {
                     double fps = ((double)m_sourceProperties.get_int("meta.media.frame_rate_num")) / rate_den;
                     propertyMap.append({i18n("Frame rate"), QString::number(fps, 'f', 2)});
                 }
             }
             property = codecInfo + QStringLiteral("bit_rate");
             int bitrate = m_sourceProperties.get_int(property.toUtf8().constData()) / 1000;
             if (bitrate > 0) {
                 propertyMap.append({i18n("Video bitrate"), QString::number(bitrate) + QLatin1Char(' ') + i18nc("Kilobytes per seconds", "kb/s")});
             }
 
             int scan = m_sourceProperties.get_int("meta.media.progressive");
             propertyMap.append({i18n("Scanning"), (scan == 1 ? i18n("Progressive") : i18n("Interlaced"))});
 
             property = codecInfo + QStringLiteral("sample_aspect_ratio");
             double par = m_sourceProperties.get_double(property.toUtf8().constData());
             if (qFuzzyIsNull(par)) {
                 // Read media aspect ratio
                 par = m_sourceProperties.get_double("aspect_ratio");
             }
             propertyMap.append({i18n("Pixel aspect ratio"), QString::number(par, 'f', 3)});
             property = codecInfo + QStringLiteral("pix_fmt");
             propertyMap.append({i18n("Pixel format"), m_sourceProperties.get(property.toUtf8().constData())});
             property = codecInfo + QStringLiteral("colorspace");
             int colorspace = m_sourceProperties.get_int(property.toUtf8().constData());
             propertyMap.append({i18n("Colorspace"), ProfileRepository::getColorspaceDescription(colorspace)});
         }
         if (default_audio > -1) {
             propertyMap.append({i18n("Audio streams"), QString::number(m_controller->audioStreamsCount())});
 
             QString codecInfo = QString("meta.media.%1.codec.").arg(default_audio);
             QString property = codecInfo + QStringLiteral("long_name");
             QString codec = m_sourceProperties.get(property.toUtf8().constData());
             if (!codec.isEmpty()) {
                 propertyMap.append({i18n("Audio codec"), codec});
             }
             property = codecInfo + QStringLiteral("channels");
             int channels = m_sourceProperties.get_int(property.toUtf8().constData());
             propertyMap.append({i18n("Audio channels"), QString::number(channels)});
 
             property = codecInfo + QStringLiteral("sample_rate");
             int srate = m_sourceProperties.get_int(property.toUtf8().constData());
             propertyMap.append({i18n("Audio frequency"), QString::number(srate) + QLatin1Char(' ') + i18nc("Herz", "Hz")});
 
             property = codecInfo + QStringLiteral("bit_rate");
             int bitrate = m_sourceProperties.get_int(property.toUtf8().constData()) / 1000;
             if (bitrate > 0) {
                 propertyMap.append({i18n("Audio bitrate"), QString::number(bitrate) + QLatin1Char(' ') + i18nc("Kilobytes per seconds", "kb/s")});
             }
         }
     }
 
     qint64 filesize = m_sourceProperties.get_int64("kdenlive:file_size");
     if (filesize > 0) {
         QLocale locale(QLocale::system()); // use the user's locale for getting proper separators!
         propertyMap.append({i18n("File size"), KIO::convertSize((size_t)filesize) + QStringLiteral(" (") + locale.toString(filesize) + QLatin1Char(')')});
     }
 
     for (int i = 0; i < propertyMap.count(); i++) {
         auto *item = new QTreeWidgetItem(m_propertiesTree, propertyMap.at(i));
         item->setToolTip(1, propertyMap.at(i).at(1));
     }
     m_propertiesTree->setSortingEnabled(true);
     m_propertiesTree->resizeColumnToContents(0);
 }
 
 void ClipPropertiesController::slotSeekToMarker()
 {
     auto markerModel = m_controller->getMarkerModel();
     auto current = m_markerTree->currentIndex();
     if (!current.isValid()) return;
     GenTime pos(markerModel->data(current, MarkerListModel::PosRole).toDouble());
     emit seekToFrame(pos.frames(pCore->getCurrentFps()));
 }
 
 void ClipPropertiesController::slotEditMarker()
 {
     auto markerModel = m_controller->getMarkerModel();
     auto current = m_markerTree->currentIndex();
     if (!current.isValid()) return;
     GenTime pos(markerModel->data(current, MarkerListModel::PosRole).toDouble());
     markerModel->editMarkerGui(pos, this, false, m_controller);
 }
 
 void ClipPropertiesController::slotDeleteMarker()
 {
     auto markerModel = m_controller->getMarkerModel();
     auto current = m_markerTree->currentIndex();
     if (!current.isValid()) return;
     GenTime pos(markerModel->data(current, MarkerListModel::PosRole).toDouble());
     markerModel->removeMarker(pos);
 }
 
 void ClipPropertiesController::slotAddMarker()
 {
     auto markerModel = m_controller->getMarkerModel();
     GenTime pos(m_controller->originalProducer()->position(), m_tc.fps());
     markerModel->editMarkerGui(pos, this, true, m_controller);
 }
 
 void ClipPropertiesController::slotSaveMarkers()
 {
     QScopedPointer<QFileDialog> fd(new QFileDialog(this, i18n("Save Clip Markers"), pCore->projectManager()->current()->projectDataFolder()));
     fd->setMimeTypeFilters(QStringList() << QStringLiteral("application/json") << QStringLiteral("text/plain"));
     fd->setFileMode(QFileDialog::AnyFile);
     fd->setAcceptMode(QFileDialog::AcceptSave);
     if (fd->exec() != QDialog::Accepted) {
         return;
     }
     QStringList selection = fd->selectedFiles();
     QString url;
     if (!selection.isEmpty()) {
         url = selection.first();
     }
     if (url.isEmpty()) {
         return;
     }
     QFile file(url);
     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         KMessageBox::error(this, i18n("Cannot open file %1", QUrl::fromLocalFile(url).fileName()));
         return;
     }
     file.write(m_controller->getMarkerModel()->toJson().toUtf8());
     file.close();
 }
 
 void ClipPropertiesController::slotLoadMarkers()
 {
     QScopedPointer<QFileDialog> fd(new QFileDialog(this, i18n("Load Clip Markers"), pCore->projectManager()->current()->projectDataFolder()));
     fd->setMimeTypeFilters(QStringList() << QStringLiteral("application/json") << QStringLiteral("text/plain"));
     fd->setFileMode(QFileDialog::ExistingFile);
     if (fd->exec() != QDialog::Accepted) {
         return;
     }
     QStringList selection = fd->selectedFiles();
     QString url;
     if (!selection.isEmpty()) {
         url = selection.first();
     }
     if (url.isEmpty()) {
         return;
     }
     QFile file(url);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         KMessageBox::error(this, i18n("Cannot open file %1", QUrl::fromLocalFile(url).fileName()));
         return;
     }
     QString fileContent = QString::fromUtf8(file.readAll());
     file.close();
     bool res = m_controller->getMarkerModel()->importFromJson(fileContent, false);
     if (!res) {
         KMessageBox::error(this, i18n("An error occurred while parsing the marker file"));
     }
 }
 
 void ClipPropertiesController::slotFillMeta(QTreeWidget *tree)
 {
     tree->clear();
     if (m_type != ClipType::AV && m_type != ClipType::Video && m_type != ClipType::Image) {
         // Currently, we only use exiftool on video files
         return;
     }
     int exifUsed = m_controller->getProducerIntProperty(QStringLiteral("kdenlive:exiftool"));
     if (exifUsed == 1) {
         Mlt::Properties subProperties;
         subProperties.pass_values(*m_properties, "kdenlive:meta.exiftool.");
         if (subProperties.count() > 0) {
             QTreeWidgetItem *exif = new QTreeWidgetItem(tree, QStringList() << i18n("Exif") << QString());
             exif->setExpanded(true);
             for (int i = 0; i < subProperties.count(); i++) {
                 new QTreeWidgetItem(exif, QStringList() << subProperties.get_name(i) << subProperties.get(i));
             }
         }
     } else if (KdenliveSettings::use_exiftool()) {
         QString url = m_controller->clipUrl();
         // Check for Canon THM file
         url = url.section(QLatin1Char('.'), 0, -2) + QStringLiteral(".THM");
         if (QFile::exists(url)) {
             // Read the exif metadata embedded in the THM file
             QProcess p;
             QStringList args;
             args << QStringLiteral("-g") << QStringLiteral("-args") << url;
             p.start(QStringLiteral("exiftool"), args);
             p.waitForFinished();
             QString res = p.readAllStandardOutput();
             m_controller->setProducerProperty(QStringLiteral("kdenlive:exiftool"), 1);
             QTreeWidgetItem *exif = nullptr;
             QStringList list = res.split(QLatin1Char('\n'));
             for (const QString &tagline : list) {
                 if (tagline.startsWith(QLatin1String("-File")) || tagline.startsWith(QLatin1String("-ExifTool"))) {
                     continue;
                 }
                 QString tag = tagline.section(QLatin1Char(':'), 1).simplified();
                 if (tag.startsWith(QLatin1String("ImageWidth")) || tag.startsWith(QLatin1String("ImageHeight"))) {
                     continue;
                 }
                 if (!tag.section(QLatin1Char('='), 0, 0).isEmpty() && !tag.section(QLatin1Char('='), 1).simplified().isEmpty()) {
                     if (!exif) {
                         exif = new QTreeWidgetItem(tree, QStringList() << i18n("Exif") << QString());
                         exif->setExpanded(true);
                     }
                     m_controller->setProducerProperty("kdenlive:meta.exiftool." + tag.section(QLatin1Char('='), 0, 0),
                                                       tag.section(QLatin1Char('='), 1).simplified());
                     new QTreeWidgetItem(exif, QStringList() << tag.section(QLatin1Char('='), 0, 0) << tag.section(QLatin1Char('='), 1).simplified());
                 }
             }
         } else {
             if (m_type == ClipType::Image || m_controller->codec(false) == QLatin1String("h264")) {
                 QProcess p;
                 QStringList args;
                 args << QStringLiteral("-g") << QStringLiteral("-args") << m_controller->clipUrl();
                 p.start(QStringLiteral("exiftool"), args);
                 p.waitForFinished();
                 QString res = p.readAllStandardOutput();
                 if (m_type != ClipType::Image) {
                     m_controller->setProducerProperty(QStringLiteral("kdenlive:exiftool"), 1);
                 }
                 QTreeWidgetItem *exif = nullptr;
                 QStringList list = res.split(QLatin1Char('\n'));
                 for (const QString &tagline : list) {
                     if (m_type != ClipType::Image && !tagline.startsWith(QLatin1String("-H264"))) {
                         continue;
                     }
                     QString tag = tagline.section(QLatin1Char(':'), 1);
                     if (tag.startsWith(QLatin1String("ImageWidth")) || tag.startsWith(QLatin1String("ImageHeight"))) {
                         continue;
                     }
                     if (!exif) {
                         exif = new QTreeWidgetItem(tree, QStringList() << i18n("Exif") << QString());
                         exif->setExpanded(true);
                     }
                     if (m_type != ClipType::Image) {
                         // Do not store image exif metadata in project file, would be too much noise
                         m_controller->setProducerProperty("kdenlive:meta.exiftool." + tag.section(QLatin1Char('='), 0, 0),
                                                           tag.section(QLatin1Char('='), 1).simplified());
                     }
                     new QTreeWidgetItem(exif, QStringList() << tag.section(QLatin1Char('='), 0, 0) << tag.section(QLatin1Char('='), 1).simplified());
                 }
             }
         }
     }
     int magic = m_controller->getProducerIntProperty(QStringLiteral("kdenlive:magiclantern"));
     if (magic == 1) {
         Mlt::Properties subProperties;
         subProperties.pass_values(*m_properties, "kdenlive:meta.magiclantern.");
         QTreeWidgetItem *magicL = nullptr;
         for (int i = 0; i < subProperties.count(); i++) {
             if (!magicL) {
                 magicL = new QTreeWidgetItem(tree, QStringList() << i18n("Magic Lantern") << QString());
                 QIcon icon(QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("meta_magiclantern.png")));
                 magicL->setIcon(0, icon);
                 magicL->setExpanded(true);
             }
             new QTreeWidgetItem(magicL, QStringList() << subProperties.get_name(i) << subProperties.get(i));
         }
     } else if (m_type != ClipType::Image && KdenliveSettings::use_magicLantern()) {
         QString url = m_controller->clipUrl();
         url = url.section(QLatin1Char('.'), 0, -2) + QStringLiteral(".LOG");
         if (QFile::exists(url)) {
             QFile file(url);
             if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                 m_controller->setProducerProperty(QStringLiteral("kdenlive:magiclantern"), 1);
                 QTreeWidgetItem *magicL = nullptr;
                 while (!file.atEnd()) {
                     QString line = file.readLine().simplified();
                     if (line.startsWith('#') || line.isEmpty() || !line.contains(QLatin1Char(':'))) {
                         continue;
                     }
                     if (line.startsWith(QLatin1String("CSV data"))) {
                         break;
                     }
                     m_controller->setProducerProperty("kdenlive:meta.magiclantern." + line.section(QLatin1Char(':'), 0, 0).simplified(),
                                                       line.section(QLatin1Char(':'), 1).simplified());
                     if (!magicL) {
                         magicL = new QTreeWidgetItem(tree, QStringList() << i18n("Magic Lantern") << QString());
                         QIcon icon(QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("meta_magiclantern.png")));
                         magicL->setIcon(0, icon);
                         magicL->setExpanded(true);
                     }
                     new QTreeWidgetItem(magicL, QStringList()
                                                     << line.section(QLatin1Char(':'), 0, 0).simplified() << line.section(QLatin1Char(':'), 1).simplified());
                 }
             }
         }
 
         // if (!meta.isEmpty())
         // clip->setMetadata(meta, "Magic Lantern");
         // clip->setProperty("magiclantern", "1");
     }
     tree->resizeColumnToContents(0);
 }
 
 void ClipPropertiesController::slotFillAnalysisData()
 {
     m_analysisTree->clear();
     Mlt::Properties subProperties;
     subProperties.pass_values(*m_properties, "kdenlive:clipanalysis.");
     if (subProperties.count() > 0) {
         for (int i = 0; i < subProperties.count(); i++) {
             new QTreeWidgetItem(m_analysisTree, QStringList() << subProperties.get_name(i) << subProperties.get(i));
         }
     }
     m_analysisTree->resizeColumnToContents(0);
 }
 
 void ClipPropertiesController::slotDeleteAnalysis()
 {
     QTreeWidgetItem *current = m_analysisTree->currentItem();
     if (!current) {
         return;
     }
     emit editAnalysis(m_id, "kdenlive:clipanalysis." + current->text(0), QString());
 }
 
 void ClipPropertiesController::slotSaveAnalysis()
 {
     const QString url =
         QFileDialog::getSaveFileName(this, i18n("Save Analysis Data"), QFileInfo(m_controller->clipUrl()).absolutePath(), i18n("Text File (*.txt)"));
     if (url.isEmpty()) {
         return;
     }
     KSharedConfigPtr config = KSharedConfig::openConfig(url, KConfig::SimpleConfig);
     KConfigGroup analysisConfig(config, "Analysis");
     QTreeWidgetItem *current = m_analysisTree->currentItem();
     analysisConfig.writeEntry(current->text(0), current->text(1));
 }
 
 void ClipPropertiesController::slotLoadAnalysis()
 {
     const QString url =
         QFileDialog::getOpenFileName(this, i18n("Open Analysis Data"), QFileInfo(m_controller->clipUrl()).absolutePath(), i18n("Text File (*.txt)"));
     if (url.isEmpty()) {
         return;
     }
     KSharedConfigPtr config = KSharedConfig::openConfig(url, KConfig::SimpleConfig);
     KConfigGroup transConfig(config, "Analysis");
     // read the entries
     QMap<QString, QString> profiles = transConfig.entryMap();
     QMapIterator<QString, QString> i(profiles);
     while (i.hasNext()) {
         i.next();
         emit editAnalysis(m_id, "kdenlive:clipanalysis." + i.key(), i.value());
     }
 }
 
 void ClipPropertiesController::slotTextChanged()
 {
     QMap<QString, QString> properties;
     properties.insert(QStringLiteral("templatetext"), m_textEdit->toPlainText());
     emit updateClipProperties(m_id, m_originalProperties, properties);
     m_originalProperties = properties;
 }
diff --git a/src/monitor/recmanager.cpp b/src/monitor/recmanager.cpp
index e4ad9c320..e338151ad 100644
--- a/src/monitor/recmanager.cpp
+++ b/src/monitor/recmanager.cpp
@@ -1,494 +1,486 @@
 /***************************************************************************
  *   Copyright (C) 2015 by 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 "recmanager.h"
 #include "capture/managecapturesdialog.h"
 #include "capture/mltdevicecapture.h"
 #include "core.h"
 #include "dialogs/profilesdialog.h"
 #include "kdenlivesettings.h"
 #include "monitor.h"
 
 #include "klocalizedstring.h"
 #include <KMessageBox>
 
 #include <QComboBox>
 #include <QScreen>
 #include <QDir>
 #include <QFile>
 #include <QMenu>
 #include <QStandardPaths>
 #include <QToolBar>
 #include <QToolButton>
 #include <QWidgetAction>
 
 RecManager::RecManager(Monitor *parent)
     : QObject(parent)
     , m_monitor(parent)
     , m_recToolbar(new QToolBar(parent))
     , m_checkAudio(false)
     , m_checkVideo(false)
     , m_screenIndex(0)
 {
     m_playAction = m_recToolbar->addAction(QIcon::fromTheme(QStringLiteral("media-playback-start")), i18n("Preview"));
     m_playAction->setCheckable(true);
     connect(m_playAction, &QAction::toggled, this, &RecManager::slotPreview);
 
     m_recAction = new QAction(QIcon::fromTheme(QStringLiteral("media-record")), i18n("Record"));
     m_recAction->setCheckable(true);
     connect(m_recAction, &QAction::toggled, this, &RecManager::slotRecord);
 
     m_showLogAction = new QAction(i18n("Show log"), this);
     connect(m_showLogAction, &QAction::triggered, this, &RecManager::slotShowLog);
 
     m_recVideo = new QCheckBox(i18n("Video"));
     m_recAudio = new QCheckBox(i18n("Audio"));
     m_recToolbar->addWidget(m_recVideo);
     m_recToolbar->addWidget(m_recAudio);
     m_recAudio->setChecked(KdenliveSettings::v4l_captureaudio());
     m_recVideo->setChecked(KdenliveSettings::v4l_capturevideo());
 
     QWidget *spacer = new QWidget(parent);
     spacer->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
     m_recToolbar->addWidget(spacer);
 
     m_audio_device = new QComboBox(parent);
     QStringList audioDevices = pCore->getAudioCaptureDevices();
     m_audio_device->addItems(audioDevices);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_audio_device, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &RecManager::slotAudioDeviceChanged);
-#else
-    connect(m_audio_device, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this, &RecManager::slotAudioDeviceChanged);
-#endif
     QString selectedDevice = KdenliveSettings::defaultaudiocapture();
     int selectedIndex = m_audio_device->findText(selectedDevice);
     if (!selectedDevice.isNull() && selectedIndex > -1) {
         m_audio_device->setCurrentIndex(selectedIndex);
     }
     m_recToolbar->addWidget(m_audio_device);
 
     m_audioCaptureSlider = new QSlider(Qt::Vertical);
     m_audioCaptureSlider->setRange(0, 100);
     m_audioCaptureSlider->setValue(KdenliveSettings::audiocapturevolume());
     connect(m_audioCaptureSlider, &QSlider::valueChanged, this, &RecManager::slotSetVolume);
     auto *widgetslider = new QWidgetAction(parent);
     widgetslider->setText(i18n("Audio Capture Volume"));
     widgetslider->setDefaultWidget(m_audioCaptureSlider);
     auto *menu = new QMenu(parent);
     menu->addAction(widgetslider);
     m_audioCaptureButton = new QToolButton(parent);
     m_audioCaptureButton->setMenu(menu);
     m_audioCaptureButton->setToolTip(i18n("Audio Capture Volume"));
     m_audioCaptureButton->setPopupMode(QToolButton::InstantPopup);
     QIcon icon;
     if (KdenliveSettings::audiocapturevolume() == 0) {
         icon = QIcon::fromTheme(QStringLiteral("audio-volume-muted"));
     } else {
         icon = QIcon::fromTheme(QStringLiteral("audio-volume-medium"));
     }
     m_audioCaptureButton->setIcon(icon);
     m_recToolbar->addWidget(m_audioCaptureButton);
     m_recToolbar->addSeparator();
 
     m_device_selector = new QComboBox(parent);
     // TODO: re-implement firewire / decklink capture
     // m_device_selector->addItems(QStringList() << i18n("Firewire") << i18n("Webcam") << i18n("Screen Grab") << i18n("Blackmagic Decklink"));
     m_device_selector->addItem(i18n("Webcam"), Video4Linux);
     m_device_selector->addItem(i18n("Screen Grab"), ScreenGrab);
     selectedIndex = m_device_selector->findData(KdenliveSettings::defaultcapture());
 
     if (selectedIndex > -1) {
         m_device_selector->setCurrentIndex(selectedIndex);
     }
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_device_selector, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &RecManager::slotVideoDeviceChanged);
-#else
-    connect(m_device_selector, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this, &RecManager::slotVideoDeviceChanged);
-#endif
     m_recToolbar->addWidget(m_device_selector);
 
     QAction *configureRec = m_recToolbar->addAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure Recording"));
     connect(configureRec, &QAction::triggered, this, &RecManager::showRecConfig);
     m_recToolbar->addSeparator();
     m_switchRec = m_recToolbar->addAction(QIcon::fromTheme(QStringLiteral("list-add")), i18n("Show Record Control"));
     m_switchRec->setCheckable(true);
     connect(m_switchRec, &QAction::toggled, m_monitor, &Monitor::slotSwitchRec);
     m_recToolbar->setVisible(false);
     slotVideoDeviceChanged();
     connect(m_monitor, &Monitor::screenChanged, this, &RecManager::slotSetScreen);
 }
 
 RecManager::~RecManager() = default;
 
 void RecManager::showRecConfig()
 {
     pCore->showConfigDialog(4, m_device_selector->currentData().toInt());
 }
 
 QToolBar *RecManager::toolbar() const
 {
     return m_recToolbar;
 }
 
 QAction *RecManager::recAction() const
 {
     return m_recAction;
 }
 
 void RecManager::stopCapture()
 {
     if (m_captureProcess) {
         slotRecord(false);
     } else if (pCore->getMediaCaptureState() == 1 && (m_checkAudio || m_checkVideo)) {
         // QMediaRecorder::RecordingState value is 1
         pCore->stopMediaCapture(-1, m_checkAudio, m_checkVideo);
         m_monitor->slotOpenClip(nullptr);
     }
 }
 
 void RecManager::stop()
 {
     if (m_captureProcess) {
         // Don't stop screen rec when hiding rec toolbar
     } else {
         stopCapture();
         m_switchRec->setChecked(false);
     }
     toolbar()->setVisible(false);
 }
 
 void RecManager::slotRecord(bool record)
 {
     /*if (m_device_selector->currentData().toInt() == Video4Linux) {
         if (record) {
             m_checkAudio = m_recAudio->isChecked();
             m_checkVideo = m_recVideo->isChecked();
             pCore->startMediaCapture(m_checkAudio, m_checkVideo);
         } else {
             stopCapture();
         }
         return;
     }*/
     if (!record) {
         if (!m_captureProcess) {
             return;
         }
         m_captureProcess->write("q");
         if (!m_captureProcess->waitForFinished()) {
             m_captureProcess->terminate();
             QTimer::singleShot(1500, m_captureProcess, &QProcess::kill);
         }
         return;
     }
     if (m_captureProcess) {
         return;
     }
     m_recError.clear();
 
     QString extension = KdenliveSettings::grab_extension();
     QDir captureFolder;
     if (KdenliveSettings::capturetoprojectfolder()) {
         captureFolder = QDir(pCore->getProjectFolderName());
     } else {
         captureFolder = QDir(KdenliveSettings::capturefolder());
     }
 
     QFileInfo checkCaptureFolder(captureFolder.absolutePath());
     if (!checkCaptureFolder.isWritable()) {
         emit warningMessage(i18n("The directory %1, could not be created.\nPlease "
                                  "make sure you have the required permissions.",
                                  captureFolder.absolutePath()));
         m_recAction->blockSignals(true);
         m_recAction->setChecked(false);
         m_recAction->blockSignals(false);
         return;
     }
 
     m_captureProcess = new QProcess;
     connect(m_captureProcess, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &RecManager::slotProcessStatus);
     connect(m_captureProcess, &QProcess::readyReadStandardError, this, &RecManager::slotReadProcessInfo);
 
     QString path = captureFolder.absoluteFilePath("capture0000." + extension);
     int i = 1;
     while (QFile::exists(path)) {
         QString num = QString::number(i).rightJustified(4, '0', false);
         path = captureFolder.absoluteFilePath("capture" + num + QLatin1Char('.') + extension);
         ++i;
     }
     m_captureFile = QUrl::fromLocalFile(path);
     QStringList captureArgs;
 #ifdef Q_OS_WIN
     captureArgs << QStringLiteral("-f") << QStringLiteral("gdigrab")
                 << QStringLiteral("-framerate") << QString::number(KdenliveSettings::grab_fps())
                 << QStringLiteral("-i") << QStringLiteral("desktop");
     if (KdenliveSettings::grab_parameters().contains(QLatin1String("alsa"))) {
         // Add audio device
         QString params = captureArgs.join(QLatin1Char(' '));
         params.append(QStringLiteral(" ") +  KdenliveSettings::grab_parameters().simplified());
         // Use Windows dshow for audio capture
         params.replace(QLatin1String("alsa"), QStringLiteral("dshow"));
         // Remove vorbis codec
         params.replace(QLatin1String("-acodec libvorbis"), QString());
 
         // Find first audio device
         QProcess tst;
         tst.setProcessChannelMode(QProcess::MergedChannels);
         tst.start(KdenliveSettings::ffmpegpath(), {"-hide_banner","-list_devices","true","-f","dshow","-i","dummy"});
         tst.waitForStarted();
         tst.waitForFinished();
         QString dshowOutput = QString::fromUtf8(tst.readAllStandardOutput());
         //KMessageBox::information(QApplication::activeWindow(), dshowOutput);
         if (dshowOutput.contains(QLatin1String("DirectShow audio devices"))) {
             dshowOutput = dshowOutput.section(QLatin1String("DirectShow audio devices"), 1);
             qDebug()<<"GOT FILTERED DSOW1: "<<dshowOutput;
             //dshowOutput = dshowOutput.section(QLatin1Char('"'), 3, 3);
             if (dshowOutput.contains(QLatin1Char('"'))) {
                 dshowOutput = QString("audio=\"%1\"").arg(dshowOutput.section(QLatin1Char('"'), 1, 1));
                 qDebug().noquote()<<"GOT FILTERED DSOW2: "<<dshowOutput;
             //captureArgs << params.split(QLatin1Char(' '));
             //captureArgs.replace(captureArgs.indexOf(QLatin1String("default")), dshowOutput);
                 params.replace(QLatin1String("default"), dshowOutput);
             }
         } else {
             qDebug()<<KdenliveSettings::ffmpegpath()<<"=== GOT DSHOW DEVICES: "<<dshowOutput;
             captureArgs << params.split(QLatin1Char(' '));
         }
         params.replace(QStringLiteral("\\\\"), QStringLiteral("\\"));
         params.replace(QStringLiteral("\\\""), QStringLiteral("\""));
         qDebug().noquote()<<"== STARTING WIN CAPTURE: "<<params<<"\n___________";
         params.append(QStringLiteral(" ") + path);
         qDebug().noquote()<<"== STARTING WIN CAPTURE: "<<params<<"\n___________";
         m_captureProcess->setNativeArguments(params);
         m_captureProcess->start(KdenliveSettings::ffmpegpath());
     } else if (!KdenliveSettings::grab_parameters().simplified().isEmpty()) {
         captureArgs << KdenliveSettings::grab_parameters().simplified().split(QLatin1Char(' '));
         captureArgs << path;
         m_captureProcess->start(KdenliveSettings::ffmpegpath(), captureArgs);
     }
 #else
     captureArgs << QStringLiteral("-f") << QStringLiteral("x11grab");
     if (KdenliveSettings::grab_follow_mouse()) {
         captureArgs << QStringLiteral("-follow_mouse") << QStringLiteral("centered");
     }
     if (!KdenliveSettings::grab_hide_frame()) {
         captureArgs << QStringLiteral("-show_region") << QStringLiteral("1");
     }
     QString captureSize = QStringLiteral(":0.0");
     if (KdenliveSettings::grab_capture_type() == 0) {
         // Full screen capture
         QRect screenSize = QApplication::screens()[m_screenIndex]->geometry();
         captureArgs << QStringLiteral("-s") << QString::number(screenSize.width()) + QLatin1Char('x') + QString::number(screenSize.height());
         captureSize.append(QLatin1Char('+') + QString::number(screenSize.left()) + QLatin1Char('.') + QString::number(screenSize.top()));
     } else {
         // Region capture
         captureArgs << QStringLiteral("-s")
                     << QString::number(KdenliveSettings::grab_width()) + QLatin1Char('x') + QString::number(KdenliveSettings::grab_height());
         captureSize.append(QLatin1Char('+') + QString::number(KdenliveSettings::grab_offsetx()) + QLatin1Char(',') +
                            QString::number(KdenliveSettings::grab_offsety()));
     }
     if (KdenliveSettings::grab_hide_mouse()) {
         captureSize.append(QStringLiteral("+nomouse"));
     }
     // fps
     captureArgs << QStringLiteral("-r") << QString::number(KdenliveSettings::grab_fps());
     captureArgs << QStringLiteral("-i") << captureSize;
     if (!KdenliveSettings::grab_parameters().simplified().isEmpty()) {
         captureArgs << KdenliveSettings::grab_parameters().simplified().split(QLatin1Char(' '));
     }
     qDebug()<<"== STARTING X11 CAPTURE: "<<captureArgs<<"\n___________";
     captureArgs << path;
     m_captureProcess->start(KdenliveSettings::ffmpegpath(), captureArgs);
 #endif
     
     if (!m_captureProcess->waitForStarted()) {
         // Problem launching capture app
         emit warningMessage(i18n("Failed to start the capture application:\n%1", KdenliveSettings::ffmpegpath()));
         // delete m_captureProcess;
     }
 }
 
 void RecManager::slotProcessStatus(int exitCode, QProcess::ExitStatus exitStatus)
 {
     m_recAction->setEnabled(true);
     m_recAction->setChecked(false);
     m_device_selector->setEnabled(true);
     if (exitStatus == QProcess::CrashExit) {
         emit warningMessage(i18n("Capture crashed, please check your parameters"), -1, QList<QAction *>() << m_showLogAction);
     } else {
         if (exitCode != 0 && exitCode != 255) {
             emit warningMessage(i18n("Capture crashed, please check your parameters"), -1, QList<QAction *>() << m_showLogAction);
         } else {
             // Capture successful, add clip to project
             emit addClipToProject(m_captureFile);
         }
     }
     if (m_captureProcess) {
         delete m_captureProcess;
         m_captureProcess = nullptr;
     }
 }
 
 void RecManager::slotReadProcessInfo()
 {
     QString data = m_captureProcess->readAllStandardError().simplified();
     m_recError.append(data + QLatin1Char('\n'));
 }
 
 void RecManager::slotAudioDeviceChanged(int)
 {
     QString currentDevice = m_audio_device->currentText();
     KdenliveSettings::setDefaultaudiocapture(currentDevice);
 }
 
 void RecManager::slotSetVolume(int volume)
 {
     KdenliveSettings::setAudiocapturevolume(volume);
     QIcon icon;
 
     if (volume == 0) {
         icon = QIcon::fromTheme(QStringLiteral("audio-volume-muted"));
     } else {
         icon = QIcon::fromTheme(QStringLiteral("audio-volume-medium"));
     }
     m_audioCaptureButton->setIcon(icon);
 }
 void RecManager::slotVideoDeviceChanged(int)
 {
     int currentItem = m_device_selector->currentData().toInt();
     KdenliveSettings::setDefaultcapture(currentItem);
     switch (currentItem) {
     case Video4Linux:
         m_playAction->setEnabled(true);
         break;
     case BlackMagic:
         m_playAction->setEnabled(false);
         break;
     default:
         m_playAction->setEnabled(false);
         break;
     }
     /*
     m_previewSettings->setEnabled(ix == Video4Linux || ix == BlackMagic);
     control_frame->setVisible(ix == Video4Linux);
     monitor_box->setVisible(ix == ScreenBag && monitor_box->count() > 0);
     m_playAction->setVisible(ix != ScreenBag);
     m_fwdAction->setVisible(ix == Firewire);
     m_discAction->setVisible(ix == Firewire);
     m_rewAction->setVisible(ix == Firewire);
     m_recAction->setEnabled(ix != Firewire);
     m_logger.setVisible(ix == BlackMagic);
     if (m_captureDevice) {
         // MLT capture still running, abort
         m_monitorManager->clearScopeSource();
         m_captureDevice->stop();
         delete m_captureDevice;
         m_captureDevice = nullptr;
     }
 
     // The m_videoBox container has to be shown once before the MLT consumer is build, or preview will fail
     switch (ix) {
     case ScreenBag:
     }
     */
 }
 
 Mlt::Producer *RecManager::createV4lProducer()
 {
     QString profilePath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/profiles/video4linux");
     Mlt::Profile *vidProfile = new Mlt::Profile(profilePath.toUtf8().constData());
     Mlt::Producer *prod = nullptr;
     if (m_recVideo->isChecked()) {
         prod = new Mlt::Producer(*vidProfile, QStringLiteral("video4linux2:%1").arg(KdenliveSettings::video4vdevice()).toUtf8().constData());
         if ((prod == nullptr) || !prod->is_valid()) {
             return nullptr;
         }
         prod->set("width", vidProfile->width());
         prod->set("height", vidProfile->height());
         prod->set("framerate", vidProfile->fps());
         /*p->set("standard", ui->v4lStandardCombo->currentText().toLatin1().constData());
         p->set("channel", ui->v4lChannelSpinBox->value());
         p->set("audio_ix", ui->v4lAudioComboBox->currentIndex());*/
         prod->set("force_seekable", 0);
     }
     if (m_recAudio->isChecked() && (prod != nullptr) && prod->is_valid()) {
         // Add audio track
         Mlt::Producer *audio = new Mlt::Producer(
             *vidProfile,
             QStringLiteral("alsa:%1?channels=%2").arg(KdenliveSettings::v4l_alsadevicename()).arg(KdenliveSettings::alsachannels()).toUtf8().constData());
         audio->set("mlt_service", "avformat-novalidate");
         audio->set("audio_index", 0);
         audio->set("video_index", -1);
         auto *tractor = new Mlt::Tractor(*vidProfile);
         tractor->set_track(*prod, 0);
         delete prod;
         tractor->set_track(*audio, 1);
         delete audio;
         prod = new Mlt::Producer(tractor->get_producer());
         delete tractor;
     }
     return prod;
 }
 
 void RecManager::slotSetScreen(int screenIndex)
 {
     m_screenIndex = screenIndex;
 }
 
 void RecManager::slotPreview(bool preview)
 {
     if (m_device_selector->currentData().toInt() == Video4Linux) {
         if (preview) {
             std::shared_ptr<Mlt::Producer> prod(createV4lProducer());
             if (prod && prod->is_valid()) {
                 m_monitor->updateClipProducer(prod);
             } else {
                 emit warningMessage(i18n("Capture crashed, please check your parameters"));
             }
         } else {
             m_monitor->slotOpenClip(nullptr);
         }
     }
 
     /*
        buildMltDevice(path);
 
        bool isXml;
        producer = getV4lXmlPlaylist(profile, &isXml);
 
        //producer =
     QString("avformat-novalidate:video4linux2:%1?width:%2&height:%3&frame_rate:%4").arg(KdenliveSettings::video4vdevice()).arg(profile.width).arg(profile.height).arg((double)
     profile.frame_rate_num / profile.frame_rate_den);
        if (!m_captureDevice->slotStartPreview(producer, isXml)) {
            // v4l capture failed to start
            video_frame->setText(i18n("Failed to start Video4Linux,\ncheck your parameters..."));
 
        } else {
            m_playAction->setEnabled(false);
            m_stopAction->setEnabled(true);
            m_isPlaying = true;
        }
     }*/
 }
 
 void RecManager::slotShowLog()
 {
     KMessageBox::information(QApplication::activeWindow(), m_recError);
 }
diff --git a/src/project/dialogs/profilewidget.cpp b/src/project/dialogs/profilewidget.cpp
index 61e0722e1..46e2b174d 100644
--- a/src/project/dialogs/profilewidget.cpp
+++ b/src/project/dialogs/profilewidget.cpp
@@ -1,277 +1,269 @@
 /*
 Copyright (C) 2016  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 "profilewidget.h"
 #include "kdenlivesettings.h"
 #include "kxmlgui_version.h"
 #include "profiles/profilemodel.hpp"
 #include "profiles/profilerepository.hpp"
 #include "profiles/tree/profilefilter.hpp"
 #include "profiles/tree/profiletreemodel.hpp"
 
 #include <KLocalizedString>
 #include <QComboBox>
 #include <QHeaderView>
 #include <QLabel>
 #include <QSplitter>
 #include <QTextEdit>
 #include <QTreeView>
 
 ProfileWidget::ProfileWidget(QWidget *parent)
     : QWidget(parent)
 {
     m_originalProfile = QStringLiteral("invalid");
     setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
     auto *lay = new QVBoxLayout;
     lay->setContentsMargins(0, 0, 0, 0);
     auto *labelLay = new QHBoxLayout;
     QLabel *fpsLabel = new QLabel(i18n("Fps"), this);
     m_fpsFilt = new QComboBox(this);
     fpsLabel->setBuddy(m_fpsFilt);
     labelLay->addWidget(fpsLabel);
     labelLay->addWidget(m_fpsFilt);
 
     QLabel *scanningLabel = new QLabel(i18n("Scanning"), this);
     m_scanningFilt = new QComboBox(this);
     scanningLabel->setBuddy(m_scanningFilt);
     labelLay->addWidget(scanningLabel);
     labelLay->addWidget(m_scanningFilt);
     labelLay->addStretch(1);
 
     auto *manage_profiles = new QToolButton(this);
     labelLay->addWidget(manage_profiles);
     manage_profiles->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     manage_profiles->setToolTip(i18n("Manage project profiles"));
     connect(manage_profiles, &QAbstractButton::clicked, this, &ProfileWidget::slotEditProfiles);
     lay->addLayout(labelLay);
 
     auto *profileSplitter = new QSplitter;
 
     m_treeView = new QTreeView(this);
     m_treeModel = ProfileTreeModel::construct(this);
     m_filter = new ProfileFilter(this);
     m_filter->setSourceModel(m_treeModel.get());
     m_treeView->setModel(m_filter);
     for (int i = 1; i < m_treeModel->columnCount(); ++i) {
         m_treeView->hideColumn(i);
     }
     m_treeView->header()->hide();
     QItemSelectionModel *selectionModel = m_treeView->selectionModel();
     connect(selectionModel, &QItemSelectionModel::currentRowChanged, this, &ProfileWidget::slotChangeSelection);
     connect(selectionModel, &QItemSelectionModel::selectionChanged, [&](const QItemSelection &selected, const QItemSelection &deselected) {
         QModelIndex current, old;
         if (!selected.indexes().isEmpty()) {
             current = selected.indexes().front();
         }
         if (!deselected.indexes().isEmpty()) {
             old = deselected.indexes().front();
         }
         slotChangeSelection(current, old);
     });
     int treeViewFontHeight = QFontInfo(m_treeView->font()).pixelSize();
     m_treeView->setMinimumHeight(treeViewFontHeight);
     profileSplitter->addWidget(m_treeView);
     m_treeView->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
     m_descriptionPanel = new QTextEdit(this);
     m_descriptionPanel->setReadOnly(true);
     m_descriptionPanel->viewport()->setCursor(Qt::ArrowCursor);
     m_descriptionPanel->viewport()->setBackgroundRole(QPalette::Mid);
     m_descriptionPanel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     m_descriptionPanel->setFrameStyle(QFrame::NoFrame);
     m_descriptionPanel->setMinimumHeight(treeViewFontHeight);
     profileSplitter->addWidget(m_descriptionPanel);
 
     lay->addWidget(profileSplitter);
     profileSplitter->setStretchFactor(0, 4);
     profileSplitter->setStretchFactor(1, 3);
 
     refreshFpsCombo();
     auto updateFps = [&]() {
         double current = m_fpsFilt->currentData().toDouble();
         KdenliveSettings::setProfile_fps_filter(m_fpsFilt->currentText());
         m_filter->setFilterFps(current > 0, current);
         slotFilterChanged();
     };
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_fpsFilt, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), updateFps);
-#else
-    connect(m_fpsFilt, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , updateFps);
-#endif
     int ix = m_fpsFilt->findText(KdenliveSettings::profile_fps_filter());
     if (ix > -1) {
         m_fpsFilt->setCurrentIndex(ix);
     }
     m_scanningFilt->addItem(i18n("Any"), -1);
     m_scanningFilt->addItem(i18n("Interlaced"), 0);
     m_scanningFilt->addItem(i18n("Progressive"), 1);
 
     auto updateScanning = [&]() {
         int current = m_scanningFilt->currentData().toInt();
         KdenliveSettings::setProfile_scanning_filter(m_scanningFilt->currentText());
         m_filter->setFilterInterlaced(current != -1, current == 0);
         slotFilterChanged();
     };
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_scanningFilt, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), updateScanning);
-#else
-    connect(m_scanningFilt, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , updateScanning);
-#endif
 
     ix = m_scanningFilt->findText(KdenliveSettings::profile_scanning_filter());
     if (ix > -1) {
         m_scanningFilt->setCurrentIndex(ix);
     }
     setLayout(lay);
 }
 
 ProfileWidget::~ProfileWidget() = default;
 
 void ProfileWidget::refreshFpsCombo()
 {
     QLocale locale;
     QVariant currentValue;
     if (m_fpsFilt->count() > 1) {
         // remember last selected value
         currentValue = m_fpsFilt->currentData();
     }
     m_fpsFilt->clear();
     locale.setNumberOptions(QLocale::OmitGroupSeparator);
     m_fpsFilt->addItem(i18n("Any"), -1);
     auto all_fps = ProfileRepository::get()->getAllFps();
     for (double fps : all_fps) {
         m_fpsFilt->addItem(locale.toString(fps), fps);
     }
     if (currentValue.isValid()) {
         int ix = m_fpsFilt->findData(currentValue);
         if (ix > -1) {
             m_fpsFilt->setCurrentIndex(ix);
         }
     }
 }
 
 void ProfileWidget::loadProfile(const QString &profile)
 {
     auto index = m_treeModel->findProfile(profile);
     if (index.isValid()) {
         m_originalProfile = m_currentProfile = m_lastValidProfile = profile;
         if (!trySelectProfile(profile)) {
             // When loading a profile, ensure it is visible so reset filters if necessary
             m_fpsFilt->setCurrentIndex(0);
             m_scanningFilt->setCurrentIndex(0);
         }
     }
 }
 
 const QString ProfileWidget::selectedProfile() const
 {
     return m_currentProfile;
 }
 
 void ProfileWidget::slotEditProfiles()
 {
     auto *w = new ProfilesDialog(m_currentProfile);
     w->exec();
     if (w->profileTreeChanged()) {
         // Rebuild profiles tree
         m_treeModel.reset();
         m_treeModel = ProfileTreeModel::construct(this);
         m_filter->setSourceModel(m_treeModel.get());
         refreshFpsCombo();
         loadProfile(m_currentProfile);
     }
     delete w;
 }
 
 void ProfileWidget::fillDescriptionPanel(const QString &profile_path)
 {
     QString description;
     if (profile_path.isEmpty()) {
         description += i18n("No profile selected");
     } else {
         std::unique_ptr<ProfileModel> &profile = ProfileRepository::get()->getProfile(profile_path);
 
         description += i18n("<h5>Video Settings</h5>");
         description += i18n("<p style='font-size:small'>Frame size: %1 x %2 (%3:%4)<br/>", profile->width(), profile->height(), profile->display_aspect_num(),
                             profile->display_aspect_den());
         description += i18n("Frame rate: %1 fps<br/>", profile->fps());
         description += i18n("Pixel Aspect Ratio: %1<br/>", profile->sar());
         description += i18n("Color Space: %1<br/>", profile->colorspaceDescription());
         QString interlaced = i18n("yes");
         if (profile->progressive()) {
             interlaced = i18n("no");
         }
         description += i18n("Interlaced: %1</p>", interlaced);
     }
     m_descriptionPanel->setHtml(description);
 }
 
 void ProfileWidget::slotChangeSelection(const QModelIndex &current, const QModelIndex &previous)
 {
     auto originalIndex = m_filter->mapToSource(current);
     if (m_treeModel->parent(originalIndex) == QModelIndex()) {
         // in that case, we have selected a category, which we don't want
         QItemSelectionModel *selection = m_treeView->selectionModel();
         selection->select(previous, QItemSelectionModel::Select);
         return;
     }
     m_currentProfile = m_treeModel->getProfile(originalIndex);
     if (!m_currentProfile.isEmpty()) {
         m_lastValidProfile = m_currentProfile;
     }
     if (m_originalProfile != m_currentProfile) {
         emit profileChanged();
     }
     fillDescriptionPanel(m_currentProfile);
 }
 
 bool ProfileWidget::trySelectProfile(const QString &profile)
 {
     auto index = m_treeModel->findProfile(profile);
     if (index.isValid()) {
         // check if element is visible
         if (m_filter->isVisible(index)) {
             // reselect
             QItemSelectionModel *selection = m_treeView->selectionModel();
             selection->select(m_filter->mapFromSource(index), QItemSelectionModel::Select);
             // expand corresponding category
             auto parent = m_treeModel->parent(index);
             m_treeView->expand(m_filter->mapFromSource(parent));
             m_treeView->scrollTo(m_filter->mapFromSource(index), QAbstractItemView::PositionAtCenter);
             return true;
         }
     }
     return false;
 }
 
 void ProfileWidget::slotFilterChanged()
 {
     // When filtering change, we must check if the current profile is still visible.
     if (!trySelectProfile(m_currentProfile)) {
         // we try to back-up the last valid profile
         if (!trySelectProfile(m_lastValidProfile)) {
             // Everything fails, we don't have any profile
             m_currentProfile = QString();
             emit profileChanged();
             fillDescriptionPanel(QString());
         }
     }
 }
diff --git a/src/project/dialogs/projectsettings.cpp b/src/project/dialogs/projectsettings.cpp
index 1f626dc3b..cd7f1e544 100644
--- a/src/project/dialogs/projectsettings.cpp
+++ b/src/project/dialogs/projectsettings.cpp
@@ -1,898 +1,890 @@
 /***************************************************************************
  *   Copyright (C) 2016 by Jean-Baptiste Mardelle (jb@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) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "projectsettings.h"
 
 #include "bin/bin.h"
 #include "bin/projectclip.h"
 #include "bin/projectfolder.h"
 #include "bin/projectitemmodel.h"
 #include "core.h"
 #include "dialogs/encodingprofilesdialog.h"
 #include "dialogs/profilesdialog.h"
 #include "doc/kdenlivedoc.h"
 #include "kdenlivesettings.h"
 #include "mltcontroller/clipcontroller.h"
 #include "profiles/profilemodel.hpp"
 #include "project/dialogs/profilewidget.h"
 #include "project/dialogs/temporarydata.h"
 #include "titler/titlewidget.h"
 #include "xml/xml.hpp"
 
 #include "kdenlive_debug.h"
 #include <KIO/FileCopyJob>
 #include <KMessageBox>
 #include <kio/directorysizejob.h>
 #include <klocalizedstring.h>
 
 #include <QDir>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QTemporaryFile>
 #include <QStyledItemDelegate>
 
 class NoEditDelegate : public QStyledItemDelegate
 {
 public:
     NoEditDelegate(QObject *parent = nullptr)
         : QStyledItemDelegate(parent)
     {
     }
     QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         Q_UNUSED(parent);
         Q_UNUSED(option);
         Q_UNUSED(index);
         return nullptr;
     }
 };
 
 ProjectSettings::ProjectSettings(KdenliveDoc *doc, QMap<QString, QString> metadata, QStringList lumas, int videotracks, int audiotracks,
                                  const QString & /*projectPath*/, bool readOnlyTracks, bool savedProject, QWidget *parent)
     : QDialog(parent)
     , m_savedProject(savedProject)
     , m_lumas(std::move(lumas))
     , m_newProject(doc == nullptr)
 {
     setupUi(this);
     tabWidget->setTabBarAutoHide(true);
     auto *vbox = new QVBoxLayout;
     vbox->setContentsMargins(0, 0, 0, 0);
     m_pw = new ProfileWidget(this);
     vbox->addWidget(m_pw);
     profile_box->setLayout(vbox);
     profile_box->setTitle(i18n("Select the profile (preset) of the project"));
 
     list_search->setTreeWidget(files_list);
     project_folder->setMode(KFile::Directory);
 
     m_buttonOk = buttonBox->button(QDialogButtonBox::Ok);
     // buttonOk->setEnabled(false);
     audio_thumbs->setChecked(KdenliveSettings::audiothumbnails());
     video_thumbs->setChecked(KdenliveSettings::videothumbnails());
     audio_tracks->setValue(audiotracks);
     video_tracks->setValue(videotracks);
     connect(generate_proxy, &QAbstractButton::toggled, proxy_minsize, &QWidget::setEnabled);
     connect(generate_imageproxy, &QAbstractButton::toggled, proxy_imageminsize, &QWidget::setEnabled);
     connect(generate_imageproxy, &QAbstractButton::toggled, image_label, &QWidget::setEnabled);
     connect(generate_imageproxy, &QAbstractButton::toggled, proxy_imagesize, &QWidget::setEnabled);
     connect(video_tracks, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), [this]() {
         if (video_tracks->value() + audio_tracks->value() <= 0) {
             video_tracks->setValue(1);
         }
     });
     connect(audio_tracks, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), [this] () {
         if (video_tracks->value() + audio_tracks->value() <= 0) {
             audio_tracks->setValue(1);
         }
     });
 
     QString currentProf;
     if (doc) {
         currentProf = pCore->getCurrentProfile()->path();
         enable_proxy->setChecked(doc->getDocumentProperty(QStringLiteral("enableproxy")).toInt() != 0);
         generate_proxy->setChecked(doc->getDocumentProperty(QStringLiteral("generateproxy")).toInt() != 0);
         proxy_minsize->setValue(doc->getDocumentProperty(QStringLiteral("proxyminsize")).toInt());
         m_proxyparameters = doc->getDocumentProperty(QStringLiteral("proxyparams"));
         m_initialExternalProxyProfile = doc->getDocumentProperty(QStringLiteral("externalproxyparams"));
         generate_imageproxy->setChecked(doc->getDocumentProperty(QStringLiteral("generateimageproxy")).toInt() != 0);
         proxy_imageminsize->setValue(doc->getDocumentProperty(QStringLiteral("proxyimageminsize")).toInt());
         proxy_imagesize->setValue(doc->getDocumentProperty(QStringLiteral("proxyimagesize")).toInt());
         m_proxyextension = doc->getDocumentProperty(QStringLiteral("proxyextension"));
         external_proxy->setChecked(doc->getDocumentProperty(QStringLiteral("enableexternalproxy")).toInt() != 0);
         m_previewparams = doc->getDocumentProperty(QStringLiteral("previewparameters"));
         m_previewextension = doc->getDocumentProperty(QStringLiteral("previewextension"));
         QString storageFolder = doc->getDocumentProperty(QStringLiteral("storagefolder"));
         if (!storageFolder.isEmpty()) {
             custom_folder->setChecked(true);
         }
         project_folder->setUrl(QUrl::fromLocalFile(doc->projectTempFolder()));
         auto *cacheWidget = new TemporaryData(doc, true, this);
         connect(cacheWidget, &TemporaryData::disableProxies, this, &ProjectSettings::disableProxies);
         connect(cacheWidget, &TemporaryData::disablePreview, this, &ProjectSettings::disablePreview);
         tabWidget->addTab(cacheWidget, i18n("Cache Data"));
     } else {
         currentProf = KdenliveSettings::default_profile();
         enable_proxy->setChecked(KdenliveSettings::enableproxy());
         external_proxy->setChecked(KdenliveSettings::externalproxy());
         qDebug() << "//// INITIAL REPORT; ENABLE EXT PROCY: " << KdenliveSettings::externalproxy() << "\n++++++++";
         m_initialExternalProxyProfile = KdenliveSettings::externalProxyProfile();
         generate_proxy->setChecked(KdenliveSettings::generateproxy());
         proxy_minsize->setValue(KdenliveSettings::proxyminsize());
         m_proxyparameters = KdenliveSettings::proxyparams();
         generate_imageproxy->setChecked(KdenliveSettings::generateimageproxy());
         proxy_imageminsize->setValue(KdenliveSettings::proxyimageminsize());
         m_proxyextension = KdenliveSettings::proxyextension();
         m_previewparams = KdenliveSettings::previewparams();
         m_previewextension = KdenliveSettings::previewextension();
         custom_folder->setChecked(KdenliveSettings::customprojectfolder());
         project_folder->setUrl(QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
     }
     // Select profile
     m_pw->loadProfile(currentProf);
 
     proxy_minsize->setEnabled(generate_proxy->isChecked());
     proxy_imageminsize->setEnabled(generate_imageproxy->isChecked());
 
     loadProxyProfiles();
     loadPreviewProfiles();
     loadExternalProxyProfiles();
 
     // Proxy GUI stuff
     proxy_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     proxy_showprofileinfo->setToolTip(i18n("Show default profile parameters"));
     proxy_manageprofile->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     proxy_manageprofile->setToolTip(i18n("Manage proxy profiles"));
 
     connect(proxy_manageprofile, &QAbstractButton::clicked, this, &ProjectSettings::slotManageEncodingProfile);
     proxy_profile->setToolTip(i18n("Select default proxy profile"));
 
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(proxy_profile, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &ProjectSettings::slotUpdateProxyParams);
-#else
-    connect(proxy_profile, QOverload<int, const QString &>::of(&QComboBox::currentIndexChanged), this, &ProjectSettings::slotUpdateProxyParams);
-#endif
     proxyparams->setVisible(false);
     proxyparams->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
     connect(proxy_showprofileinfo, &QAbstractButton::clicked, proxyparams, &QWidget::setVisible);
 
     external_proxy_profile->setToolTip(i18n("Select camcorder profile"));
 
     // Preview GUI stuff
     preview_showprofileinfo->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     preview_showprofileinfo->setToolTip(i18n("Show default profile parameters"));
     preview_manageprofile->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     preview_manageprofile->setToolTip(i18n("Manage timeline preview profiles"));
 
     connect(preview_manageprofile, &QAbstractButton::clicked, this, &ProjectSettings::slotManagePreviewProfile);
     preview_profile->setToolTip(i18n("Select default preview profile"));
 
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(preview_profile, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &ProjectSettings::slotUpdatePreviewParams);
-#else
-    connect(preview_profile, QOverload<int, const QString &>::of(&QComboBox::currentIndexChanged), this, &ProjectSettings::slotUpdatePreviewParams);
-#endif
     previewparams->setVisible(false);
     previewparams->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
     connect(preview_showprofileinfo, &QAbstractButton::clicked, previewparams, &QWidget::setVisible);
 
     if (readOnlyTracks) {
         video_tracks->setEnabled(false);
         audio_tracks->setEnabled(false);
     }
 
     metadata_list->setItemDelegateForColumn(0, new NoEditDelegate(this));
     connect(metadata_list, &QTreeWidget::itemDoubleClicked, this, &ProjectSettings::slotEditMetadata);
 
     // Metadata list
     QTreeWidgetItem *item = new QTreeWidgetItem(metadata_list, QStringList() << i18n("Title"));
     item->setData(0, Qt::UserRole, QStringLiteral("meta.attr.title.markup"));
     if (metadata.contains(QStringLiteral("meta.attr.title.markup"))) {
         item->setText(1, metadata.value(QStringLiteral("meta.attr.title.markup")));
         metadata.remove(QStringLiteral("meta.attr.title.markup"));
     }
     item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     item = new QTreeWidgetItem(metadata_list, QStringList() << i18n("Author"));
     item->setData(0, Qt::UserRole, QStringLiteral("meta.attr.author.markup"));
     if (metadata.contains(QStringLiteral("meta.attr.author.markup"))) {
         item->setText(1, metadata.value(QStringLiteral("meta.attr.author.markup")));
         metadata.remove(QStringLiteral("meta.attr.author.markup"));
     } else if (metadata.contains(QStringLiteral("meta.attr.artist.markup"))) {
         item->setText(0, i18n("Artist"));
         item->setData(0, Qt::UserRole, QStringLiteral("meta.attr.artist.markup"));
         item->setText(1, metadata.value(QStringLiteral("meta.attr.artist.markup")));
         metadata.remove(QStringLiteral("meta.attr.artist.markup"));
     }
     item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     item = new QTreeWidgetItem(metadata_list, QStringList() << i18n("Copyright"));
     item->setData(0, Qt::UserRole, QStringLiteral("meta.attr.copyright.markup"));
     if (metadata.contains(QStringLiteral("meta.attr.copyright.markup"))) {
         item->setText(1, metadata.value(QStringLiteral("meta.attr.copyright.markup")));
         metadata.remove(QStringLiteral("meta.attr.copyright.markup"));
     }
     item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     item = new QTreeWidgetItem(metadata_list, QStringList() << i18n("Year"));
     item->setData(0, Qt::UserRole, QStringLiteral("meta.attr.year.markup"));
     if (metadata.contains(QStringLiteral("meta.attr.year.markup"))) {
         item->setText(1, metadata.value(QStringLiteral("meta.attr.year.markup")));
         metadata.remove(QStringLiteral("meta.attr.year.markup"));
     } else if (metadata.contains(QStringLiteral("meta.attr.date.markup"))) {
         item->setText(0, i18n("Date"));
         item->setData(0, Qt::UserRole, QStringLiteral("meta.attr.date.markup"));
         item->setText(1, metadata.value(QStringLiteral("meta.attr.date.markup")));
         metadata.remove(QStringLiteral("meta.attr.date.markup"));
     }
     item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 
     QMap<QString, QString>::const_iterator meta = metadata.constBegin();
     while (meta != metadata.constEnd()) {
         item = new QTreeWidgetItem(metadata_list, QStringList() << meta.key().section(QLatin1Char('.'), 2, 2));
         item->setData(0, Qt::UserRole, meta.key());
         item->setText(1, meta.value());
         item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
         ++meta;
     }
 
     connect(add_metadata, &QAbstractButton::clicked, this, &ProjectSettings::slotAddMetadataField);
     connect(delete_metadata, &QAbstractButton::clicked, this, &ProjectSettings::slotDeleteMetadataField);
     add_metadata->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
     delete_metadata->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
 
     if (doc != nullptr) {
         slotUpdateFiles();
         connect(delete_unused, &QAbstractButton::clicked, this, &ProjectSettings::slotDeleteUnused);
     } else {
         tabWidget->removeTab(2);
         tabWidget->removeTab(1);
     }
     connect(project_folder, &KUrlRequester::textChanged, this, &ProjectSettings::slotUpdateButton);
     connect(button_export, &QAbstractButton::clicked, this, &ProjectSettings::slotExportToText);
     // Delete unused files is not implemented
     delete_unused->setVisible(false);
 }
 
 void ProjectSettings::slotEditMetadata(QTreeWidgetItem *item, int)
 {
     metadata_list->editItem(item, 1);
 }
 
 void ProjectSettings::slotDeleteUnused()
 {
     QStringList toDelete;
     // TODO
     /*
     QList<DocClipBase*> list = m_projectList->documentClipList();
     for (int i = 0; i < list.count(); ++i) {
         DocClipBase *clip = list.at(i);
         if (clip->numReferences() == 0 && clip->clipType() != SlideShow) {
             QUrl url = clip->fileURL();
             if (url.isValid() && !toDelete.contains(url.path())) toDelete << url.path();
         }
     }
 
     // make sure our urls are not used in another clip
     for (int i = 0; i < list.count(); ++i) {
         DocClipBase *clip = list.at(i);
         if (clip->numReferences() > 0) {
             QUrl url = clip->fileURL();
             if (url.isValid() && toDelete.contains(url.path())) toDelete.removeAll(url.path());
         }
     }
 
     if (toDelete.count() == 0) {
         // No physical url to delete, we only remove unused clips from project (color clips for example have no physical url)
         if (KMessageBox::warningContinueCancel(this, i18n("This will remove all unused clips from your project."), i18n("Clean up project")) ==
     KMessageBox::Cancel) return;
         m_projectList->cleanup();
         slotUpdateFiles();
         return;
     }
     if (KMessageBox::warningYesNoList(this, i18n("This will remove the following files from your hard drive.\nThis action cannot be undone, only use if you know
     what you are doing.\nAre you sure you want to continue?"), toDelete, i18n("Delete unused clips")) != KMessageBox::Yes) return;
     m_projectList->trashUnusedClips();
     slotUpdateFiles();
     */
 }
 
 void ProjectSettings::slotUpdateFiles(bool cacheOnly)
 {
     qDebug() << "// UPDATING PROJECT FILES\n----------\n-----------";
     m_projectProxies.clear();
     m_projectThumbs.clear();
     if (cacheOnly) {
         return;
     }
     files_list->clear();
 
     // List all files that are used in the project. That also means:
     // images included in slideshow and titles, files in playlist clips
     // TODO: images used in luma transitions?
 
     // Setup categories
     QTreeWidgetItem *videos = new QTreeWidgetItem(files_list, QStringList() << i18n("Video clips"));
     videos->setIcon(0, QIcon::fromTheme(QStringLiteral("video-x-generic")));
     videos->setExpanded(true);
     QTreeWidgetItem *sounds = new QTreeWidgetItem(files_list, QStringList() << i18n("Audio clips"));
     sounds->setIcon(0, QIcon::fromTheme(QStringLiteral("audio-x-generic")));
     sounds->setExpanded(true);
     QTreeWidgetItem *images = new QTreeWidgetItem(files_list, QStringList() << i18n("Image clips"));
     images->setIcon(0, QIcon::fromTheme(QStringLiteral("image-x-generic")));
     images->setExpanded(true);
     QTreeWidgetItem *slideshows = new QTreeWidgetItem(files_list, QStringList() << i18n("Slideshow clips"));
     slideshows->setIcon(0, QIcon::fromTheme(QStringLiteral("image-x-generic")));
     slideshows->setExpanded(true);
     QTreeWidgetItem *texts = new QTreeWidgetItem(files_list, QStringList() << i18n("Text clips"));
     texts->setIcon(0, QIcon::fromTheme(QStringLiteral("text-plain")));
     texts->setExpanded(true);
     QTreeWidgetItem *playlists = new QTreeWidgetItem(files_list, QStringList() << i18n("Playlist clips"));
     playlists->setIcon(0, QIcon::fromTheme(QStringLiteral("video-mlt-playlist")));
     playlists->setExpanded(true);
     QTreeWidgetItem *others = new QTreeWidgetItem(files_list, QStringList() << i18n("Other clips"));
     others->setIcon(0, QIcon::fromTheme(QStringLiteral("unknown")));
     others->setExpanded(true);
     int count = 0;
     QStringList allFonts;
     for (const QString &file : m_lumas) {
         count++;
         new QTreeWidgetItem(images, QStringList() << file);
     }
     QList<std::shared_ptr<ProjectClip>> clipList = pCore->projectItemModel()->getRootFolder()->childClips();
     for (const std::shared_ptr<ProjectClip> &clip : clipList) {
         switch (clip->clipType()) {
         case ClipType::Color:
             // ignore color clips in list, there is no real file
             break;
         case ClipType::SlideShow: {
             const QStringList subfiles = extractSlideshowUrls(clip->clipUrl());
             for (const QString &file : subfiles) {
                 count++;
                 new QTreeWidgetItem(slideshows, QStringList() << file);
             }
             break;
         }
         case ClipType::Text: {
             new QTreeWidgetItem(texts, QStringList() << clip->clipUrl());
             const QStringList imagefiles = TitleWidget::extractImageList(clip->getProducerProperty(QStringLiteral("xmldata")));
             const QStringList fonts = TitleWidget::extractFontList(clip->getProducerProperty(QStringLiteral("xmldata")));
             for (const QString &file : imagefiles) {
                 new QTreeWidgetItem(images, QStringList() << file);
             }
             allFonts << fonts;
             break;
         }
         case ClipType::Audio:
             new QTreeWidgetItem(sounds, QStringList() << clip->clipUrl());
             break;
         case ClipType::Image:
             new QTreeWidgetItem(images, QStringList() << clip->clipUrl());
             break;
         case ClipType::Playlist: {
             new QTreeWidgetItem(playlists, QStringList() << clip->clipUrl());
             const QStringList files = extractPlaylistUrls(clip->clipUrl());
             for (const QString &file : files) {
                 new QTreeWidgetItem(others, QStringList() << file);
             }
             break;
         }
         case ClipType::Unknown:
             new QTreeWidgetItem(others, QStringList() << clip->clipUrl());
             break;
         default:
             new QTreeWidgetItem(videos, QStringList() << clip->clipUrl());
             break;
         }
     }
 
     uint used = 0;
     uint unUsed = 0;
     qint64 usedSize = 0;
     qint64 unUsedSize = 0;
     pCore->bin()->getBinStats(&used, &unUsed, &usedSize, &unUsedSize);
     allFonts.removeDuplicates();
     // Hide unused categories
     for (int j = 0; j < files_list->topLevelItemCount(); ++j) {
         if (files_list->topLevelItem(j)->childCount() == 0) {
             files_list->topLevelItem(j)->setHidden(true);
         }
     }
     files_count->setText(QString::number(count));
     fonts_list->addItems(allFonts);
     if (allFonts.isEmpty()) {
         fonts_list->setHidden(true);
         label_fonts->setHidden(true);
     }
     used_count->setText(QString::number(used));
     used_size->setText(KIO::convertSize(static_cast<KIO::filesize_t>(usedSize)));
     unused_count->setText(QString::number(unUsed));
     unused_size->setText(KIO::convertSize(static_cast<KIO::filesize_t>(unUsedSize)));
     delete_unused->setEnabled(unUsed > 0);
 }
 
 const QString ProjectSettings::selectedPreview() const
 {
     return preview_profile->itemData(preview_profile->currentIndex()).toString();
 }
 
 void ProjectSettings::accept()
 {
     if (selectedProfile().isEmpty()) {
         KMessageBox::error(this, i18n("Please select a video profile"));
         return;
     }
     QString params = preview_profile->itemData(preview_profile->currentIndex()).toString();
     if (!params.isEmpty()) {
         if (params.section(QLatin1Char(';'), 0, 0) != m_previewparams || params.section(QLatin1Char(';'), 1, 1) != m_previewextension) {
             // Timeline preview settings changed, warn if there are existing previews
             if (pCore->hasTimelinePreview() &&
                 KMessageBox::warningContinueCancel(this,
                                                    i18n("You changed the timeline preview profile. This will remove all existing timeline previews for "
                                                         "this project.\n Are you sure you want to proceed?"),
                                                    i18n("Confirm profile change")) == KMessageBox::Cancel) {
                 return;
             }
         }
     }
     if (!m_newProject && selectedProfile() != pCore->getCurrentProfile()->path()) {
         if (KMessageBox::warningContinueCancel(
                 this,
                 i18n("Changing the profile of your project cannot be undone.\nIt is recommended to save your project before attempting this operation "
                      "that might cause some corruption in transitions.\nAre you sure you want to proceed?"),
                 i18n("Confirm profile change")) == KMessageBox::Cancel) {
             return;
         }
     }
     QDialog::accept();
 }
 
 void ProjectSettings::slotUpdateButton(const QString &path)
 {
     if (path.isEmpty()) {
         m_buttonOk->setEnabled(false);
     } else {
         m_buttonOk->setEnabled(true);
         slotUpdateFiles(true);
     }
 }
 
 QString ProjectSettings::selectedProfile() const
 {
     return m_pw->selectedProfile();
 }
 
 QUrl ProjectSettings::selectedFolder() const
 {
     return project_folder->url();
 }
 
 QPoint ProjectSettings::tracks() const
 {
     QPoint p;
     p.setX(video_tracks->value());
     p.setY(audio_tracks->value());
     return p;
 }
 
 bool ProjectSettings::enableVideoThumbs() const
 {
     return video_thumbs->isChecked();
 }
 
 bool ProjectSettings::enableAudioThumbs() const
 {
     return audio_thumbs->isChecked();
 }
 
 bool ProjectSettings::useProxy() const
 {
     return enable_proxy->isChecked();
 }
 
 bool ProjectSettings::useExternalProxy() const
 {
     return external_proxy->isChecked();
 }
 
 bool ProjectSettings::generateProxy() const
 {
     return generate_proxy->isChecked();
 }
 
 bool ProjectSettings::generateImageProxy() const
 {
     return generate_imageproxy->isChecked();
 }
 
 int ProjectSettings::proxyMinSize() const
 {
     return proxy_minsize->value();
 }
 
 int ProjectSettings::proxyImageMinSize() const
 {
     return proxy_imageminsize->value();
 }
 
 int ProjectSettings::proxyImageSize() const
 {
     return proxy_imagesize->value();
 }
 
 QString ProjectSettings::externalProxyParams() const
 {
     return external_proxy_profile->currentData().toString();
 }
 
 QString ProjectSettings::proxyParams() const
 {
     QString params = proxy_profile->currentData().toString();
     return params.section(QLatin1Char(';'), 0, 0);
 }
 
 QString ProjectSettings::proxyExtension() const
 {
     QString params = proxy_profile->currentData().toString();
     return params.section(QLatin1Char(';'), 1, 1);
 }
 
 QString ProjectSettings::previewParams() const
 {
     QString params = preview_profile->itemData(preview_profile->currentIndex()).toString();
     return params.section(QLatin1Char(';'), 0, 0);
 }
 
 QString ProjectSettings::previewExtension() const
 {
     QString params = preview_profile->itemData(preview_profile->currentIndex()).toString();
     return params.section(QLatin1Char(';'), 1, 1);
 }
 
 // static
 QStringList ProjectSettings::extractPlaylistUrls(const QString &path)
 {
     QStringList urls;
     QDomDocument doc;
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly)) {
         return urls;
     }
     if (!doc.setContent(&file)) {
         file.close();
         return urls;
     }
     file.close();
     QString root = doc.documentElement().attribute(QStringLiteral("root"));
     if (!root.isEmpty() && !root.endsWith(QLatin1Char('/'))) {
         root.append(QLatin1Char('/'));
     }
     QDomNodeList files = doc.elementsByTagName(QStringLiteral("producer"));
     for (int i = 0; i < files.count(); ++i) {
         QDomElement e = files.at(i).toElement();
         QString type = Xml::getXmlProperty(e, QStringLiteral("mlt_service"));
         if (type != QLatin1String("colour")) {
             QString url = Xml::getXmlProperty(e, QStringLiteral("resource"));
             if (type == QLatin1String("timewarp")) {
                 url = Xml::getXmlProperty(e, QStringLiteral("warp_resource"));
             } else if (type == QLatin1String("framebuffer")) {
                 url = url.section(QLatin1Char('?'), 0, 0);
             }
             if (!url.isEmpty()) {
                 if (QFileInfo(url).isRelative()) {
                     url.prepend(root);
                 }
                 if (url.section(QLatin1Char('.'), 0, -2).endsWith(QLatin1String("/.all"))) {
                     // slideshow clip, extract image urls
                     urls << extractSlideshowUrls(url);
                 } else {
                     urls << url;
                 }
                 if (url.endsWith(QLatin1String(".mlt")) || url.endsWith(QLatin1String(".kdenlive"))) {
                     // TODO: Do something to avoid infinite loops if 2 files reference themselves...
                     urls << extractPlaylistUrls(url);
                 }
             }
         }
     }
 
     // luma files for transitions
     files = doc.elementsByTagName(QStringLiteral("transition"));
     for (int i = 0; i < files.count(); ++i) {
         QDomElement e = files.at(i).toElement();
         QString url = Xml::getXmlProperty(e, QStringLiteral("resource"));
         if (!url.isEmpty()) {
             if (QFileInfo(url).isRelative()) {
                 url.prepend(root);
             }
             urls << url;
         }
     }
 
     return urls;
 }
 
 // static
 QStringList ProjectSettings::extractSlideshowUrls(const QString &url)
 {
     QStringList urls;
     QString path = QFileInfo(url).absolutePath();
     QDir dir(path);
     if (url.contains(QStringLiteral(".all."))) {
         // this is a MIME slideshow, like *.jpeg
         QString ext = url.section(QLatin1Char('.'), -1);
         QStringList filters;
         filters << QStringLiteral("*.") + ext;
         dir.setNameFilters(filters);
         QStringList result = dir.entryList(QDir::Files);
         urls.append(path + filters.at(0) + QStringLiteral(" (") + i18np("1 image found", "%1 images found", result.count()) + QLatin1Char(')'));
     } else {
         // this is a pattern slideshow, like sequence%4d.jpg
         QString filter = QFileInfo(url).fileName();
         QString ext = filter.section(QLatin1Char('.'), -1);
         filter = filter.section(QLatin1Char('%'), 0, -2);
         QString regexp = QLatin1Char('^') + filter + QStringLiteral("\\d+\\.") + ext + QLatin1Char('$');
         QRegExp rx(regexp);
         int count = 0;
         const QStringList result = dir.entryList(QDir::Files);
         for (const QString &p : result) {
             if (rx.exactMatch(p)) {
                 count++;
             }
         }
         urls.append(url + QStringLiteral(" (") + i18np("1 image found", "%1 images found", count) + QLatin1Char(')'));
     }
     return urls;
 }
 
 void ProjectSettings::slotExportToText()
 {
     QFileDialog fd(this);
     fd.setMimeTypeFilters(QStringList() << "text/plain");
     if (fd.exec() != QDialog::Accepted) { return; }
     
     const QString savePath = fd.selectedFiles().first();
     
     QString text;
     text.append(i18n("Project folder: %1", project_folder->url().toLocalFile()) + '\n');
     text.append(i18n("Project profile: %1", m_pw->selectedProfile()) + '\n');
     text.append(i18n("Total clips: %1 (%2 used in timeline).", files_count->text(), used_count->text()) + "\n\n");
     for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
         if (files_list->topLevelItem(i)->childCount() > 0) {
             text.append('\n' + files_list->topLevelItem(i)->text(0) + ":\n\n");
             for (int j = 0; j < files_list->topLevelItem(i)->childCount(); ++j) {
                 text.append(files_list->topLevelItem(i)->child(j)->text(0) + '\n');
             }
         }
     }
     QTemporaryFile tmpfile;
     if (!tmpfile.open()) {
         qCWarning(KDENLIVE_LOG) << "/////  CANNOT CREATE TMP FILE in: " << tmpfile.fileName();
         return;
     }
     QFile xmlf(tmpfile.fileName());
     if (!xmlf.open(QIODevice::WriteOnly)) {
         return;
     }
     xmlf.write(text.toUtf8());
     if (xmlf.error() != QFile::NoError) {
         xmlf.close();
         return;
     }
     xmlf.close();
     KIO::FileCopyJob *copyjob = KIO::file_copy(QUrl::fromLocalFile(tmpfile.fileName()), QUrl::fromLocalFile(savePath));
     copyjob->exec();
 }
 
 void ProjectSettings::slotUpdateProxyParams()
 {
     QString params = proxy_profile->currentData().toString();
     proxyparams->setPlainText(params.section(QLatin1Char(';'), 0, 0));
 }
 
 void ProjectSettings::slotUpdatePreviewParams()
 {
     QString params = preview_profile->currentData().toString();
     previewparams->setPlainText(params.section(QLatin1Char(';'), 0, 0));
 }
 
 const QMap<QString, QString> ProjectSettings::metadata() const
 {
     QMap<QString, QString> metadata;
     for (int i = 0; i < metadata_list->topLevelItemCount(); ++i) {
         QTreeWidgetItem *item = metadata_list->topLevelItem(i);
         if (!item->text(1).simplified().isEmpty()) {
             // Insert metadata entry
             QString key = item->data(0, Qt::UserRole).toString();
             if (key.isEmpty()) {
                 key = QStringLiteral("meta.attr.") + item->text(0).simplified() + QStringLiteral(".markup");
             }
             QString value = item->text(1);
             metadata.insert(key, value);
         }
     }
     return metadata;
 }
 
 void ProjectSettings::slotAddMetadataField()
 {
     QString metaField = QInputDialog::getText(this, i18n("Metadata"), i18n("Metadata"));
     if (metaField.isEmpty()) {
         return;
     }
     QTreeWidgetItem *item = new QTreeWidgetItem(metadata_list, QStringList() << metaField);
     item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 }
 
 void ProjectSettings::slotDeleteMetadataField()
 {
     QTreeWidgetItem *item = metadata_list->currentItem();
     if (item) {
         delete item;
     }
 }
 
 void ProjectSettings::slotManageEncodingProfile()
 {
     QPointer<EncodingProfilesDialog> d = new EncodingProfilesDialog(0);
     d->exec();
     delete d;
     loadProxyProfiles();
 }
 
 void ProjectSettings::slotManagePreviewProfile()
 {
     QPointer<EncodingProfilesDialog> d = new EncodingProfilesDialog(1);
     d->exec();
     delete d;
     loadPreviewProfiles();
 }
 
 void ProjectSettings::loadProxyProfiles()
 {
     // load proxy profiles
     KConfig conf(QStringLiteral("encodingprofiles.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     KConfigGroup group(&conf, "proxy");
     QMap<QString, QString> values = group.entryMap();
     QMapIterator<QString, QString> k(values);
     int ix = -1;
     proxy_profile->clear();
     if (KdenliveSettings::vaapiEnabled() || KdenliveSettings::nvencEnabled()) {
         proxy_profile->addItem(QIcon::fromTheme(QStringLiteral("speedometer")), i18n("Automatic"));
     } else {
         proxy_profile->addItem(i18n("Automatic"));
     }
     while (k.hasNext()) {
         k.next();
         if (!k.key().isEmpty()) {
             QString params = k.value().section(QLatin1Char(';'), 0, 0);
             QString extension = k.value().section(QLatin1Char(';'), 1, 1);
             if (ix == -1 && ((params == m_proxyparameters && extension == m_proxyextension))) {
                 // this is the current profile
                 ix = proxy_profile->count();
             }
             if (params.contains(QLatin1String("vaapi"))) {
                 proxy_profile->addItem(KdenliveSettings::vaapiEnabled() ? QIcon::fromTheme(QStringLiteral("speedometer"))
                                                                         : QIcon::fromTheme(QStringLiteral("dialog-cancel")),
                                        k.key(), k.value());
             } else if (params.contains(QLatin1String("nvenc"))) {
                 proxy_profile->addItem(KdenliveSettings::nvencEnabled() ? QIcon::fromTheme(QStringLiteral("speedometer"))
                                                                         : QIcon::fromTheme(QStringLiteral("dialog-cancel")),
                                        k.key(), k.value());
             } else {
                 proxy_profile->addItem(k.key(), k.value());
             }
         }
     }
     if (ix == -1) {
         // Current project proxy settings not found
         if (m_proxyparameters.isEmpty() && m_proxyextension.isEmpty()) {
             ix = 0;
         } else {
             ix = proxy_profile->count();
             proxy_profile->addItem(i18n("Current Settings"), QString(m_proxyparameters + QLatin1Char(';') + m_proxyextension));
         }
     }
     proxy_profile->setCurrentIndex(ix);
     slotUpdateProxyParams();
 }
 
 void ProjectSettings::loadExternalProxyProfiles()
 {
     // load proxy profiles
     KConfig conf(QStringLiteral("externalproxies.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     KConfigGroup group(&conf, "proxy");
     QMap<QString, QString> values = group.entryMap();
     QMapIterator<QString, QString> k(values);
     int ix = -1;
     external_proxy_profile->clear();
     while (k.hasNext()) {
         k.next();
         if (!k.key().isEmpty()) {
             if (ix == -1 && k.value() == m_initialExternalProxyProfile) {
                 // this is the current profile
                 ix = external_proxy_profile->count();
             }
             if (k.value().contains(QLatin1Char(';'))) {
                 external_proxy_profile->addItem(k.key(), k.value());
             }
         }
     }
     if (ix == -1 && !m_initialExternalProxyProfile.isEmpty()) {
         // Current project proxy settings not found
         ix = external_proxy_profile->count();
         external_proxy_profile->addItem(i18n("Current Settings"), m_initialExternalProxyProfile);
     }
     external_proxy_profile->setCurrentIndex(ix);
 }
 
 void ProjectSettings::loadPreviewProfiles()
 {
     // load proxy profiles
     KConfig conf(QStringLiteral("encodingprofiles.rc"), KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     KConfigGroup group(&conf, "timelinepreview");
     QMap<QString, QString> values = group.entryMap();
     QMapIterator<QString, QString> k(values);
     int ix = -1;
     preview_profile->clear();
     while (k.hasNext()) {
         k.next();
         if (!k.key().isEmpty()) {
             QString params = k.value().section(QLatin1Char(';'), 0, 0);
             QString extension = k.value().section(QLatin1Char(';'), 1, 1);
             if (ix == -1 && (params == m_previewparams && extension == m_previewextension)) {
                 // this is the current profile
                 ix = preview_profile->count();
             }
             if (params.contains(QLatin1String("nvenc"))) {
                 preview_profile->addItem(KdenliveSettings::nvencEnabled() ? QIcon::fromTheme(QStringLiteral("speedometer"))
                                                                           : QIcon::fromTheme(QStringLiteral("dialog-cancel")),
                                          k.key(), k.value());
             } else {
                 preview_profile->addItem(k.key(), k.value());
             }
         }
     }
     if (ix == -1) {
         // Current project proxy settings not found
         ix = preview_profile->count();
         if (m_previewparams.isEmpty() && m_previewextension.isEmpty()) {
             // Leave empty, will be automatically detected
             if (KdenliveSettings::nvencEnabled()) {
                 preview_profile->addItem(QIcon::fromTheme(QStringLiteral("speedometer")), i18n("Automatic"));
             } else {
                 preview_profile->addItem(i18n("Automatic"));
             }
         } else {
             if (m_previewparams.contains(QLatin1String("nvenc"))) {
                 preview_profile->addItem(QIcon::fromTheme(QStringLiteral("speedometer")), i18n("Current Settings"),
                                          QString(m_previewparams + QLatin1Char(';') + m_previewextension));
             } else {
                 preview_profile->addItem(i18n("Current Settings"), QString(m_previewparams + QLatin1Char(';') + m_previewextension));
             }
         }
     }
     preview_profile->setCurrentIndex(ix);
     slotUpdatePreviewParams();
 }
 
 const QString ProjectSettings::storageFolder() const
 {
     if (custom_folder->isChecked()) {
         return project_folder->url().toLocalFile();
     }
     return QString();
 }
diff --git a/src/titler/titlewidget.cpp b/src/titler/titlewidget.cpp
index 1db946678..58f522d93 100644
--- a/src/titler/titlewidget.cpp
+++ b/src/titler/titlewidget.cpp
@@ -1,3168 +1,3164 @@
 /***************************************************************************
                           titlewidget.cpp  -  description
                              -------------------
     begin                : Feb 28 2008
     copyright            : (C) 2008 by Marco Gittler
     email                : g.marco@freenet.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "titlewidget.h"
 #include "core.h"
 #include "doc/kthumb.h"
 #include "gradientwidget.h"
 #include "kdenlivesettings.h"
 #include "monitor/monitor.h"
 
 #include <cmath>
 
 #include <KMessageBox>
 #include <KMessageWidget>
 #include <KRecentDirs>
 #include <klocalizedstring.h>
 #include <kns3/downloaddialog.h>
 
 #include "kdenlive_debug.h"
 #include <QButtonGroup>
 #include <QCryptographicHash>
 #include <QDomDocument>
 #include <QFileDialog>
 #include <QFontDatabase>
 #include <QGraphicsBlurEffect>
 #include <QGraphicsDropShadowEffect>
 #include <QGraphicsEffect>
 #include <QGraphicsItem>
 #include <QGraphicsSvgItem>
 #include <QImageReader>
 #include <QKeyEvent>
 #include <QSignalMapper>
 #include <QSpinBox>
 #include <QTextBlockFormat>
 #include <QTextCursor>
 #include <QTimer>
 #include <QToolBar>
 
 #include <QStandardPaths>
 #include <iostream>
 #include <mlt++/MltProfile.h>
 #include <utility>
 
 static QList<TitleTemplate> titletemplates;
 
 // What exactly is this variable good for?
 int settingUp = 0;
 
 const int IMAGEITEM = 7;
 const int RECTITEM = 3;
 const int TEXTITEM = 8;
 
 const int NOEFFECT = 0;
 const int BLUREFFECT = 1;
 const int SHADOWEFFECT = 2;
 const int TYPEWRITEREFFECT = 3;
 
 void TitleWidget::refreshTemplateBoxContents()
 {
     templateBox->clear();
     templateBox->addItem(QString());
     for (const TitleTemplate &t : titletemplates) {
         templateBox->addItem(t.icon, t.name, t.file);
     }
 }
 
 TitleWidget::TitleWidget(const QUrl &url, const Timecode &tc, QString projectTitlePath, Monitor *monitor, QWidget *parent)
     : QDialog(parent)
     , Ui::TitleWidget_UI()
     , m_startViewport(nullptr)
     , m_endViewport(nullptr)
     , m_count(0)
     , m_unicodeDialog(new UnicodeDialog(UnicodeDialog::InputHex))
     , m_missingMessage(nullptr)
     , m_projectTitlePath(std::move(projectTitlePath))
     , m_tc(tc)
     , m_fps(pCore->getCurrentFps())
     , m_guides(QList<QGraphicsLineItem *>())
 {
     setupUi(this);
     setMinimumSize(200, 200);
     setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
     frame_properties->setEnabled(false);
     frame_properties->setFixedHeight(frame_toolbar->height());
     int size = style()->pixelMetric(QStyle::PM_SmallIconSize);
     QSize iconSize(size, size);
 
     rectBColor->setAlphaChannelEnabled(true);
     rectFColor->setAlphaChannelEnabled(true);
     fontColorButton->setAlphaChannelEnabled(true);
     textOutlineColor->setAlphaChannelEnabled(true);
     shadowColor->setAlphaChannelEnabled(true);
 
     auto *colorGroup = new QButtonGroup(this);
     colorGroup->addButton(gradient_color);
     colorGroup->addButton(plain_color);
 
     auto *alignGroup = new QButtonGroup(this);
     alignGroup->addButton(buttonAlignLeft);
     alignGroup->addButton(buttonAlignCenter);
     alignGroup->addButton(buttonAlignRight);
 
     textOutline->setMinimum(0);
     textOutline->setMaximum(200);
     // textOutline->setDecimals(0);
     textOutline->setValue(0);
     textOutline->setToolTip(i18n("Outline width"));
 
     backgroundAlpha->setMinimum(0);
     backgroundAlpha->setMaximum(255);
     bgAlphaSlider->setMinimum(0);
     bgAlphaSlider->setMaximum(255);
     backgroundAlpha->setValue(0);
     backgroundAlpha->setToolTip(i18n("Background color opacity"));
 
     itemrotatex->setMinimum(-360);
     itemrotatex->setMaximum(360);
     // itemrotatex->setDecimals(0);
     itemrotatex->setValue(0);
     itemrotatex->setToolTip(i18n("Rotation around the X axis"));
 
     itemrotatey->setMinimum(-360);
     itemrotatey->setMaximum(360);
     // itemrotatey->setDecimals(0);
     itemrotatey->setValue(0);
     itemrotatey->setToolTip(i18n("Rotation around the Y axis"));
 
     itemrotatez->setMinimum(-360);
     itemrotatez->setMaximum(360);
     // itemrotatez->setDecimals(0);
     itemrotatez->setValue(0);
     itemrotatez->setToolTip(i18n("Rotation around the Z axis"));
 
     rectLineWidth->setMinimum(0);
     rectLineWidth->setMaximum(500);
     // rectLineWidth->setDecimals(0);
     rectLineWidth->setValue(0);
     rectLineWidth->setToolTip(i18n("Border width"));
 
     itemzoom->setSuffix(i18n("%"));
     QSize profileSize = pCore->getCurrentFrameSize();
     m_frameWidth = (int)(profileSize.height() * pCore->getCurrentDar() + 0.5);
     m_frameHeight = profileSize.height();
     showToolbars(TITLE_SELECT);
 
     splitter->setStretchFactor(0, 20);
 
     // If project is drop frame, set the input mask as such.
     title_duration->setInputMask(m_tc.mask());
     title_duration->setText(m_tc.reformatSeparators(KdenliveSettings::title_duration()));
 
     connect(backgroundColor, &KColorButton::changed, this, &TitleWidget::slotChangeBackground);
     connect(backgroundAlpha, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotChangeBackground);
 
     connect(shadowBox, &QGroupBox::toggled, this, &TitleWidget::slotUpdateShadow);
     connect(shadowColor, &KColorButton::changed, this, &TitleWidget::slotUpdateShadow);
     connect(blur_radius, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateShadow);
     connect(shadowX, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateShadow);
     connect(shadowY, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateShadow);
 
     connect(fontColorButton, &KColorButton::changed, this, &TitleWidget::slotUpdateText);
     connect(plain_color, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(gradient_color, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(gradients_combo, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdateText()));
 
     connect(textOutlineColor, &KColorButton::changed, this, &TitleWidget::slotUpdateText);
     connect(font_family, &QFontComboBox::currentFontChanged, this, &TitleWidget::slotUpdateText);
     connect(font_size, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateText);
     connect(letter_spacing, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateText);
     connect(line_spacing, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateText);
     connect(textOutline, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateText);
     connect(font_weight_box, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdateText()));
 
     connect(rectFColor, &KColorButton::changed, this, &TitleWidget::rectChanged);
     connect(rectBColor, &KColorButton::changed, this, &TitleWidget::rectChanged);
     connect(plain_rect, &QAbstractButton::clicked, this, &TitleWidget::rectChanged);
     connect(gradient_rect, &QAbstractButton::clicked, this, &TitleWidget::rectChanged);
     connect(gradients_rect_combo, SIGNAL(currentIndexChanged(int)), this, SLOT(rectChanged()));
     connect(rectLineWidth, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::rectChanged);
 
     connect(zValue, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::zIndexChanged);
     connect(itemzoom, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::itemScaled);
     connect(itemrotatex, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::itemRotateX);
     connect(itemrotatey, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::itemRotateY);
     connect(itemrotatez, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::itemRotateZ);
     connect(itemhcenter, &QAbstractButton::clicked, this, &TitleWidget::itemHCenter);
     connect(itemvcenter, &QAbstractButton::clicked, this, &TitleWidget::itemVCenter);
     connect(itemtop, &QAbstractButton::clicked, this, &TitleWidget::itemTop);
     connect(itembottom, &QAbstractButton::clicked, this, &TitleWidget::itemBottom);
     connect(itemleft, &QAbstractButton::clicked, this, &TitleWidget::itemLeft);
     connect(itemright, &QAbstractButton::clicked, this, &TitleWidget::itemRight);
 
     connect(origin_x_left, &QAbstractButton::clicked, this, &TitleWidget::slotOriginXClicked);
     connect(origin_y_top, &QAbstractButton::clicked, this, &TitleWidget::slotOriginYClicked);
 
     connect(monitor, &Monitor::frameUpdated, this, &TitleWidget::slotGotBackground);
     connect(this, &TitleWidget::requestBackgroundFrame, monitor, &Monitor::slotGetCurrentImage);
 
     // Position and size
     connect(value_w, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, [this](int){slotValueChanged(ValueWidth);});
     connect(value_h, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, [this](int){slotValueChanged(ValueHeight);});
     connect(value_x, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, [this](int){slotValueChanged(ValueX);});
     connect(value_y, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, [this](int){slotValueChanged(ValueY);});
 
     connect(buttonFitZoom, &QAbstractButton::clicked, this, &TitleWidget::slotAdjustZoom);
     connect(buttonRealSize, &QAbstractButton::clicked, this, &TitleWidget::slotZoomOneToOne);
     connect(buttonItalic, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(buttonUnder, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(buttonAlignLeft, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(buttonAlignRight, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(buttonAlignCenter, &QAbstractButton::clicked, this, &TitleWidget::slotUpdateText);
     connect(edit_gradient, &QAbstractButton::clicked, this, &TitleWidget::slotEditGradient);
     connect(edit_rect_gradient, &QAbstractButton::clicked, this, &TitleWidget::slotEditGradient);
     connect(displayBg, &QCheckBox::stateChanged, this, &TitleWidget::displayBackgroundFrame);
 
     connect(m_unicodeDialog, &UnicodeDialog::charSelected, this, &TitleWidget::slotInsertUnicodeString);
 
     // mbd
     connect(this, &QDialog::accepted, this, &TitleWidget::slotAccepted);
 
     font_weight_box->blockSignals(true);
     font_weight_box->addItem(i18nc("Font style", "Light"), QFont::Light);
     font_weight_box->addItem(i18nc("Font style", "Normal"), QFont::Normal);
     font_weight_box->addItem(i18nc("Font style", "Demi-Bold"), QFont::DemiBold);
     font_weight_box->addItem(i18nc("Font style", "Bold"), QFont::Bold);
     font_weight_box->addItem(i18nc("Font style", "Black"), QFont::Black);
     font_weight_box->setToolTip(i18n("Font weight"));
     font_weight_box->setCurrentIndex(1);
     font_weight_box->blockSignals(false);
 
     buttonFitZoom->setIconSize(iconSize);
     buttonRealSize->setIconSize(iconSize);
     buttonItalic->setIconSize(iconSize);
     buttonUnder->setIconSize(iconSize);
     buttonAlignCenter->setIconSize(iconSize);
     buttonAlignLeft->setIconSize(iconSize);
     buttonAlignRight->setIconSize(iconSize);
     buttonFitZoom->setIcon(QIcon::fromTheme(QStringLiteral("zoom-fit-best")));
     buttonRealSize->setIcon(QIcon::fromTheme(QStringLiteral("zoom-original")));
     buttonItalic->setIcon(QIcon::fromTheme(QStringLiteral("format-text-italic")));
     buttonUnder->setIcon(QIcon::fromTheme(QStringLiteral("format-text-underline")));
     buttonAlignCenter->setIcon(QIcon::fromTheme(QStringLiteral("format-justify-center")));
     buttonAlignLeft->setIcon(QIcon::fromTheme(QStringLiteral("format-justify-left")));
     buttonAlignRight->setIcon(QIcon::fromTheme(QStringLiteral("format-justify-right")));
     edit_gradient->setIcon(QIcon::fromTheme(QStringLiteral("document-edit")));
     edit_rect_gradient->setIcon(QIcon::fromTheme(QStringLiteral("document-edit")));
 
     buttonAlignRight->setToolTip(i18n("Align right"));
     buttonAlignLeft->setToolTip(i18n("Align left"));
     buttonAlignCenter->setToolTip(i18n("Align center"));
     if (qApp->isLeftToRight()) {
         buttonAlignRight->setChecked(true);
     } else {
         buttonAlignLeft->setChecked(true);
     }
 
     m_unicodeAction = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-insert-unicode")), QString(), this);
     m_unicodeAction->setShortcut(Qt::SHIFT + Qt::CTRL + Qt::Key_U);
     m_unicodeAction->setToolTip(getTooltipWithShortcut(i18n("Insert Unicode character"), m_unicodeAction));
     connect(m_unicodeAction, &QAction::triggered, this, &TitleWidget::slotInsertUnicode);
     buttonInsertUnicode->setDefaultAction(m_unicodeAction);
 
     m_zUp = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-up")), QString(), this);
     m_zUp->setShortcut(Qt::Key_PageUp);
     m_zUp->setToolTip(i18n("Raise object"));
     connect(m_zUp, &QAction::triggered, this, &TitleWidget::slotZIndexUp);
     zUp->setDefaultAction(m_zUp);
 
     m_zDown = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-down")), QString(), this);
     m_zDown->setShortcut(Qt::Key_PageDown);
     m_zDown->setToolTip(i18n("Lower object"));
     connect(m_zDown, &QAction::triggered, this, &TitleWidget::slotZIndexDown);
     zDown->setDefaultAction(m_zDown);
 
     m_zTop = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-top")), QString(), this);
     // TODO mbt 1414: Shortcut should change z index only if
     // cursor is NOT in a text field ...
     // m_zTop->setShortcut(Qt::Key_Home);
     m_zTop->setToolTip(i18n("Raise object to top"));
     connect(m_zTop, &QAction::triggered, this, &TitleWidget::slotZIndexTop);
     zTop->setDefaultAction(m_zTop);
 
     m_zBottom = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-bottom")), QString(), this);
     // TODO mbt 1414
     // m_zBottom->setShortcut(Qt::Key_End);
     m_zBottom->setToolTip(i18n("Lower object to bottom"));
     connect(m_zBottom, &QAction::triggered, this, &TitleWidget::slotZIndexBottom);
     zBottom->setDefaultAction(m_zBottom);
 
     m_selectAll = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-select-all")), QString(), this);
     m_selectAll->setShortcut(Qt::CTRL + Qt::Key_A);
     connect(m_selectAll, &QAction::triggered, this, &TitleWidget::slotSelectAll);
     buttonSelectAll->setDefaultAction(m_selectAll);
 
     m_selectText = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-select-texts")), QString(), this);
     m_selectText->setShortcut(Qt::CTRL + Qt::Key_T);
     connect(m_selectText, &QAction::triggered, this, &TitleWidget::slotSelectText);
     buttonSelectText->setDefaultAction(m_selectText);
     buttonSelectText->setEnabled(false);
 
     m_selectRects = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-select-rects")), QString(), this);
     m_selectRects->setShortcut(Qt::CTRL + Qt::Key_R);
     connect(m_selectRects, &QAction::triggered, this, &TitleWidget::slotSelectRects);
     buttonSelectRects->setDefaultAction(m_selectRects);
     buttonSelectRects->setEnabled(false);
 
     m_selectImages = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-select-images")), QString(), this);
     m_selectImages->setShortcut(Qt::CTRL + Qt::Key_I);
     connect(m_selectImages, &QAction::triggered, this, &TitleWidget::slotSelectImages);
     buttonSelectImages->setDefaultAction(m_selectImages);
     buttonSelectImages->setEnabled(false);
 
     m_unselectAll = new QAction(QIcon::fromTheme(QStringLiteral("kdenlive-unselect-all")), QString(), this);
     m_unselectAll->setShortcut(Qt::SHIFT + Qt::CTRL + Qt::Key_A);
     connect(m_unselectAll, &QAction::triggered, this, &TitleWidget::slotSelectNone);
     buttonUnselectAll->setDefaultAction(m_unselectAll);
     buttonUnselectAll->setEnabled(false);
 
     zDown->setIconSize(iconSize);
     zTop->setIconSize(iconSize);
     zBottom->setIconSize(iconSize);
     zDown->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-down")));
     zTop->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-top")));
     zBottom->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-zindex-bottom")));
     connect(zDown, &QAbstractButton::clicked, this, &TitleWidget::slotZIndexDown);
     connect(zTop, &QAbstractButton::clicked, this, &TitleWidget::slotZIndexTop);
     connect(zBottom, &QAbstractButton::clicked, this, &TitleWidget::slotZIndexBottom);
 
     origin_x_left->setToolTip(i18n("Invert x axis and change 0 point"));
     origin_y_top->setToolTip(i18n("Invert y axis and change 0 point"));
     rectBColor->setToolTip(i18n("Select fill color"));
     rectFColor->setToolTip(i18n("Select border color"));
     zoom_slider->setToolTip(i18n("Zoom"));
     buttonRealSize->setToolTip(i18n("Original size (1:1)"));
     buttonFitZoom->setToolTip(i18n("Fit zoom"));
     backgroundColor->setToolTip(i18n("Select background color"));
     backgroundAlpha->setToolTip(i18n("Background opacity"));
     buttonSelectAll->setToolTip(getTooltipWithShortcut(i18n("Select all"), m_selectAll));
     buttonSelectText->setToolTip(getTooltipWithShortcut(i18n("Select text items in current selection"), m_selectText));
     buttonSelectRects->setToolTip(getTooltipWithShortcut(i18n("Select rect items in current selection"), m_selectRects));
     buttonSelectImages->setToolTip(getTooltipWithShortcut(i18n("Select image items in current selection"), m_selectImages));
     buttonUnselectAll->setToolTip(getTooltipWithShortcut(i18n("Unselect all"), m_unselectAll));
 
     itemhcenter->setIconSize(iconSize);
     itemvcenter->setIconSize(iconSize);
     itemtop->setIconSize(iconSize);
     itembottom->setIconSize(iconSize);
     itemright->setIconSize(iconSize);
     itemleft->setIconSize(iconSize);
 
     itemhcenter->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-align-hor")));
     itemhcenter->setToolTip(i18n("Align item horizontally"));
     itemvcenter->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-align-vert")));
     itemvcenter->setToolTip(i18n("Align item vertically"));
     itemtop->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-align-top")));
     itemtop->setToolTip(i18n("Align item to top"));
     itembottom->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-align-bottom")));
     itembottom->setToolTip(i18n("Align item to bottom"));
     itemright->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-align-right")));
     itemright->setToolTip(i18n("Align item to right"));
     itemleft->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-align-left")));
     itemleft->setToolTip(i18n("Align item to left"));
 
     auto *layout = new QHBoxLayout;
     frame_toolbar->setLayout(layout);
     layout->setContentsMargins(0, 0, 0, 0);
     QToolBar *m_toolbar = new QToolBar(QStringLiteral("titleToolBar"), this);
     m_toolbar->setIconSize(iconSize);
 
     m_buttonCursor = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("transform-move")), i18n("Selection Tool"));
     m_buttonCursor->setCheckable(true);
     m_buttonCursor->setShortcut(Qt::ALT + Qt::Key_S);
     m_buttonCursor->setToolTip(i18n("Selection Tool") + QLatin1Char(' ') + m_buttonCursor->shortcut().toString());
     connect(m_buttonCursor, &QAction::triggered, this, &TitleWidget::slotSelectTool);
 
     m_buttonText = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("insert-text")), i18n("Add Text"));
     m_buttonText->setCheckable(true);
     m_buttonText->setShortcut(Qt::ALT + Qt::Key_T);
     m_buttonText->setToolTip(i18n("Add Text") + QLatin1Char(' ') + m_buttonText->shortcut().toString());
     connect(m_buttonText, &QAction::triggered, this, &TitleWidget::slotTextTool);
 
     m_buttonRect = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("kdenlive-insert-rect")), i18n("Add Rectangle"));
     m_buttonRect->setCheckable(true);
     m_buttonRect->setShortcut(Qt::ALT + Qt::Key_R);
     m_buttonRect->setToolTip(i18n("Add Rectangle") + QLatin1Char(' ') + m_buttonRect->shortcut().toString());
     connect(m_buttonRect, &QAction::triggered, this, &TitleWidget::slotRectTool);
 
     m_buttonImage = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("insert-image")), i18n("Add Image"));
     m_buttonImage->setCheckable(false);
     m_buttonImage->setShortcut(Qt::ALT + Qt::Key_I);
     m_buttonImage->setToolTip(i18n("Add Image") + QLatin1Char(' ') + m_buttonImage->shortcut().toString());
     connect(m_buttonImage, &QAction::triggered, this, &TitleWidget::slotImageTool);
 
     m_toolbar->addSeparator();
 
     m_buttonLoad = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("document-open")), i18n("Open Document"));
     m_buttonLoad->setCheckable(false);
     m_buttonLoad->setShortcut(Qt::CTRL + Qt::Key_O);
     m_buttonLoad->setToolTip(i18n("Open Document") + QLatin1Char(' ') + m_buttonLoad->shortcut().toString());
     connect(m_buttonLoad, SIGNAL(triggered()), this, SLOT(loadTitle()));
 
     m_buttonSave = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("document-save-as")), i18n("Save As"));
     m_buttonSave->setCheckable(false);
     m_buttonSave->setShortcut(Qt::CTRL + Qt::Key_S);
     m_buttonSave->setToolTip(i18n("Save As") + QLatin1Char(' ') + m_buttonSave->shortcut().toString());
     connect(m_buttonSave, SIGNAL(triggered()), this, SLOT(saveTitle()));
 
     m_buttonDownload = m_toolbar->addAction(QIcon::fromTheme(QStringLiteral("edit-download")), i18n("Download New Title Templates..."));
     m_buttonDownload->setCheckable(false);
     m_buttonDownload->setShortcut(Qt::ALT + Qt::Key_D);
     m_buttonDownload->setToolTip(i18n("Download New Title Templates...") + QLatin1Char(' ') + m_buttonDownload->shortcut().toString());
     connect(m_buttonDownload, &QAction::triggered, this, &TitleWidget::downloadTitleTemplates);
 
     layout->addWidget(m_toolbar);
 
     // initialize graphic scene
     m_scene = new GraphicsSceneRectMove(this);
     graphicsView->setScene(m_scene);
     graphicsView->setMouseTracking(true);
     graphicsView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
     graphicsView->setDragMode(QGraphicsView::RubberBandDrag);
     graphicsView->setRubberBandSelectionMode(Qt::ContainsItemBoundingRect);
     m_titledocument.setScene(m_scene, m_frameWidth, m_frameHeight);
     connect(m_scene, &QGraphicsScene::changed, this, &TitleWidget::slotChanged);
     connect(font_size, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_scene, &GraphicsSceneRectMove::slotUpdateFontSize);
     connect(use_grid, &QAbstractButton::toggled, m_scene, &GraphicsSceneRectMove::slotUseGrid);
 
     // Video frame rect
     QPen framepen;
     framepen.setColor(Qt::red);
     m_frameBorder = new QGraphicsRectItem(QRectF(0, 0, m_frameWidth, m_frameHeight));
     m_frameBorder->setPen(framepen);
     m_frameBorder->setZValue(1000);
     m_frameBorder->setBrush(Qt::transparent);
     m_frameBorder->setFlags(nullptr);
     m_frameBorder->setData(-1, -1);
     graphicsView->scene()->addItem(m_frameBorder);
 
     // Guides
     connect(show_guides, &QCheckBox::stateChanged, this, &TitleWidget::showGuides);
     show_guides->setChecked(KdenliveSettings::titlerShowGuides());
     hguides->setValue(KdenliveSettings::titlerHGuides());
     vguides->setValue(KdenliveSettings::titlerVGuides());
     guideColor->setColor(KdenliveSettings::titleGuideColor());
     connect(guideColor, &KColorButton::changed, this, &TitleWidget::guideColorChanged);
     connect(hguides, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::updateGuides);
     connect(vguides, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::updateGuides);
     updateGuides(0);
 
     // semi transparent safe zones
     framepen.setColor(QColor(255, 0, 0, 100));
     QGraphicsRectItem *safe1 = new QGraphicsRectItem(QRectF(m_frameWidth * 0.05, m_frameHeight * 0.05, m_frameWidth * 0.9, m_frameHeight * 0.9), m_frameBorder);
     safe1->setBrush(Qt::transparent);
     safe1->setPen(framepen);
     safe1->setFlags(nullptr);
     safe1->setData(-1, -1);
     QGraphicsRectItem *safe2 = new QGraphicsRectItem(QRectF(m_frameWidth * 0.1, m_frameHeight * 0.1, m_frameWidth * 0.8, m_frameHeight * 0.8), m_frameBorder);
     safe2->setBrush(Qt::transparent);
     safe2->setPen(framepen);
     safe2->setFlags(nullptr);
     safe2->setData(-1, -1);
 
     m_frameBackground = new QGraphicsRectItem(QRectF(0, 0, m_frameWidth, m_frameHeight));
     m_frameBackground->setZValue(-1100);
     m_frameBackground->setBrush(Qt::transparent);
     m_frameBackground->setFlags(nullptr);
     graphicsView->scene()->addItem(m_frameBackground);
 
     m_frameImage = new QGraphicsPixmapItem();
     QTransform qtrans;
     qtrans.scale(2.0, 2.0);
     m_frameImage->setTransform(qtrans);
     m_frameImage->setZValue(-1200);
     m_frameImage->setFlags(nullptr);
     displayBackgroundFrame();
     graphicsView->scene()->addItem(m_frameImage);
 
     bgBox->setCurrentIndex(KdenliveSettings::titlerbg());
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(bgBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), [&] (int ix) {
-#else
-    connect(bgBox, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , [&] (int ix) {
-#endif
         KdenliveSettings::setTitlerbg(ix);
         displayBackgroundFrame();
     });
 
     connect(m_scene, &QGraphicsScene::selectionChanged, this, &TitleWidget::selectionChanged);
     connect(m_scene, &GraphicsSceneRectMove::itemMoved, this, &TitleWidget::selectionChanged);
     connect(m_scene, &GraphicsSceneRectMove::sceneZoom, this, &TitleWidget::slotZoom);
     connect(m_scene, &GraphicsSceneRectMove::actionFinished, this, &TitleWidget::slotSelectTool);
     connect(m_scene, &GraphicsSceneRectMove::newRect, this, &TitleWidget::slotNewRect);
     connect(m_scene, &GraphicsSceneRectMove::newText, this, &TitleWidget::slotNewText);
     connect(zoom_slider, &QAbstractSlider::valueChanged, this, &TitleWidget::slotUpdateZoom);
     connect(zoom_spin, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TitleWidget::slotUpdateZoom);
 
     // mbd: load saved settings
     loadGradients();
     readChoices();
 
     graphicsView->show();
     graphicsView->setInteractive(true);
     // qCDebug(KDENLIVE_LOG) << "// TITLE WIDGWT: " << graphicsView->viewport()->width() << 'x' << graphicsView->viewport()->height();
     m_startViewport = new QGraphicsRectItem(QRectF(0, 0, m_frameWidth, m_frameHeight));
     // Setting data at -1 so that the item is recognized as undeletable by graphicsscenerectmove
     m_startViewport->setData(-1, -1);
     m_endViewport = new QGraphicsRectItem(QRectF(0, 0, m_frameWidth, m_frameHeight));
     m_endViewport->setData(-1, -1);
     m_startViewport->setData(0, m_frameWidth);
     m_startViewport->setData(1, m_frameHeight);
     m_endViewport->setData(0, m_frameWidth);
     m_endViewport->setData(1, m_frameHeight);
 
     // scale the view so that the title widget is not too big at startup
     graphicsView->scale(.5, .5);
     if (url.isValid()) {
         loadTitle(url);
     } else {
         prepareTools(nullptr);
         slotTextTool();
         QTimer::singleShot(200, this, &TitleWidget::slotAdjustZoom);
     }
     initAnimation();
     QColor color = backgroundColor->color();
     m_scene->setBackgroundBrush(QBrush(color));
     color.setAlpha(backgroundAlpha->value());
     m_frameBackground->setBrush(color);
     connect(anim_start, &QAbstractButton::toggled, this, &TitleWidget::slotAnimStart);
     connect(anim_end, &QAbstractButton::toggled, this, &TitleWidget::slotAnimEnd);
     connect(templateBox, SIGNAL(currentIndexChanged(int)), this, SLOT(templateIndexChanged(int)));
 
     buttonBox->button(QDialogButtonBox::Ok)->setEnabled(KdenliveSettings::hastitleproducer());
     if (titletemplates.isEmpty()) {
         refreshTitleTemplates(m_projectTitlePath);
     }
     // templateBox->setIconSize(QSize(60,60));
     refreshTemplateBoxContents();
     m_lastDocumentHash = QCryptographicHash::hash(xml().toString().toLatin1(), QCryptographicHash::Md5).toHex();
 }
 
 TitleWidget::~TitleWidget()
 {
     m_scene->blockSignals(true);
     delete m_buttonRect;
     delete m_buttonText;
     delete m_buttonImage;
     delete m_buttonCursor;
     delete m_buttonSave;
     delete m_buttonLoad;
     delete m_unicodeAction;
     delete m_zUp;
     delete m_zDown;
     delete m_zTop;
     delete m_zBottom;
     delete m_selectAll;
     delete m_selectText;
     delete m_selectRects;
     delete m_selectImages;
     delete m_unselectAll;
 
     delete m_unicodeDialog;
     delete m_frameBorder;
     delete m_frameImage;
     delete m_startViewport;
     delete m_endViewport;
     delete m_scene;
 }
 
 // static
 QStringList TitleWidget::extractImageList(const QString &xml)
 {
     QStringList result;
     if (xml.isEmpty()) {
         return result;
     }
     QDomDocument doc;
     doc.setContent(xml);
     QDomNodeList images = doc.elementsByTagName(QStringLiteral("content"));
     for (int i = 0; i < images.count(); ++i) {
         if (images.at(i).toElement().hasAttribute(QStringLiteral("url"))) {
             result.append(images.at(i).toElement().attribute(QStringLiteral("url")));
         }
     }
     return result;
 }
 
 // static
 QStringList TitleWidget::extractFontList(const QString &xml)
 {
     QStringList result;
     if (xml.isEmpty()) {
         return result;
     }
     QDomDocument doc;
     doc.setContent(xml);
     QDomNodeList images = doc.elementsByTagName(QStringLiteral("content"));
     for (int i = 0; i < images.count(); ++i) {
         if (images.at(i).toElement().hasAttribute(QStringLiteral("font"))) {
             result.append(images.at(i).toElement().attribute(QStringLiteral("font")));
         }
     }
     return result;
 }
 // static
 void TitleWidget::refreshTitleTemplates(const QString &projectPath)
 {
     QStringList filters = QStringList() << QStringLiteral("*.kdenlivetitle");
     titletemplates.clear();
 
     // project templates
     QDir dir(projectPath);
     QStringList templateFiles = dir.entryList(filters, QDir::Files);
     for (const QString &fname : templateFiles) {
         TitleTemplate t;
         t.name = fname;
         t.file = dir.absoluteFilePath(fname);
         t.icon = QIcon(KThumb::getImage(QUrl::fromLocalFile(t.file), 0, 60, -1));
         titletemplates.append(t);
     }
 
     // system templates
     QStringList titleTemplates = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, QStringLiteral("titles/"), QStandardPaths::LocateDirectory);
     for (const QString &folderpath : titleTemplates) {
         QDir folder(folderpath);
         QStringList filesnames = folder.entryList(filters, QDir::Files);
         for (const QString &fname : filesnames) {
             TitleTemplate t;
             t.name = fname;
             t.file = folder.absoluteFilePath(fname);
             t.icon = QIcon(KThumb::getImage(QUrl::fromLocalFile(t.file), 0, 60, -1));
             titletemplates.append(t);
         }
     }
 }
 
 void TitleWidget::templateIndexChanged(int index)
 {
     QString item = templateBox->itemData(index).toString();
     if (!item.isEmpty()) {
         if (m_lastDocumentHash != QCryptographicHash::hash(xml().toString().toLatin1(), QCryptographicHash::Md5).toHex()) {
             if (KMessageBox::questionYesNo(this, i18n("Do you really want to load a new template? Changes in this title will be lost!")) == KMessageBox::No) {
                 return;
             }
         }
         loadTitle(QUrl::fromLocalFile(item));
 
         // mbt 1607: Add property to distinguish between unchanged template titles and user titles.
         // Text of unchanged template titles should be selected when clicked.
         QList<QGraphicsItem *> list = graphicsView->scene()->items();
         for (QGraphicsItem *qgItem : list) {
             if (qgItem->type() == TEXTITEM) {
                 auto *i = static_cast<MyTextItem *>(qgItem);
                 i->setProperty("isTemplate", "true");
                 i->setProperty("templateText", i->toHtml());
             }
         }
         m_lastDocumentHash = QCryptographicHash::hash(xml().toString().toLatin1(), QCryptographicHash::Md5).toHex();
     }
 }
 // virtual
 void TitleWidget::resizeEvent(QResizeEvent * /*event*/)
 {
     // slotAdjustZoom();
 }
 // virtual
 void TitleWidget::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() != Qt::Key_Escape && e->key() != Qt::Key_Return && e->key() != Qt::Key_Enter) {
         QDialog::keyPressEvent(e);
     }
 }
 
 void TitleWidget::slotTextTool()
 {
     m_scene->setTool(TITLE_TEXT);
     showToolbars(TITLE_TEXT);
     checkButton(TITLE_TEXT);
 }
 
 void TitleWidget::slotRectTool()
 {
     m_scene->setTool(TITLE_RECTANGLE);
     showToolbars(TITLE_RECTANGLE);
     checkButton(TITLE_RECTANGLE);
 
     // Disable dragging mode, would make dragging a rect impossible otherwise ;)
     graphicsView->setDragMode(QGraphicsView::NoDrag);
 }
 
 void TitleWidget::slotSelectTool()
 {
     m_scene->setTool(TITLE_SELECT);
 
     // Enable rubberband selecting mode.
     graphicsView->setDragMode(QGraphicsView::RubberBandDrag);
 
     // Find out which toolbars need to be shown, depending on selected item
     TITLETOOL t = TITLE_SELECT;
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (!l.isEmpty()) {
         switch (l.at(0)->type()) {
         case TEXTITEM:
             t = TITLE_TEXT;
             break;
         case RECTITEM:
             t = TITLE_RECTANGLE;
             break;
         case IMAGEITEM:
             t = TITLE_IMAGE;
             break;
         }
     }
 
     enableToolbars(t);
     if (t == TITLE_RECTANGLE && (l.at(0) == m_endViewport || l.at(0) == m_startViewport)) {
         // graphicsView->centerOn(l.at(0));
         t = TITLE_SELECT;
     }
     showToolbars(t);
 
     if (!l.isEmpty()) {
         updateCoordinates(l.at(0));
         updateDimension(l.at(0));
         updateRotZoom(l.at(0));
     }
 
     checkButton(TITLE_SELECT);
 }
 
 void TitleWidget::slotImageTool()
 {
     QList<QByteArray> supported = QImageReader::supportedImageFormats();
     QStringList mimeTypeFilters;
     QString allExtensions = i18n("All Images") + QStringLiteral(" (");
     for (const QByteArray &mimeType : supported) {
         mimeTypeFilters.append(i18n("%1 Image", QString(mimeType)) + QStringLiteral("( *.") + QString(mimeType) + QLatin1Char(')'));
         allExtensions.append(QStringLiteral("*.") + mimeType + QLatin1Char(' '));
     }
     mimeTypeFilters.sort();
     allExtensions.append(QLatin1Char(')'));
     mimeTypeFilters.prepend(allExtensions);
     QString clipFolder = KRecentDirs::dir(QStringLiteral(":KdenliveImageFolder"));
     if (clipFolder.isEmpty()) {
         clipFolder = QDir::homePath();
     }
     QFileDialog dialog(this, i18n("Add Image"), clipFolder);
     dialog.setAcceptMode(QFileDialog::AcceptOpen);
     dialog.setNameFilters(mimeTypeFilters);
     if (dialog.exec() != QDialog::Accepted) {
         return;
     }
     QUrl url = QUrl::fromLocalFile(dialog.selectedFiles().at(0));
     if (url.isValid()) {
         KRecentDirs::add(QStringLiteral(":KdenliveImageFolder"), url.adjusted(QUrl::RemoveFilename).toLocalFile());
         if (url.toLocalFile().endsWith(QLatin1String(".svg"))) {
             MySvgItem *svg = new MySvgItem(url.toLocalFile());
             svg->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges);
             svg->setZValue(m_count++);
             svg->setData(Qt::UserRole, url.toLocalFile());
             m_scene->addNewItem(svg);
             prepareTools(svg);
         } else {
             QPixmap pix(url.toLocalFile());
             auto *image = new MyPixmapItem(pix);
             image->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
             image->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges);
             image->setData(Qt::UserRole, url.toLocalFile());
             image->setZValue(m_count++);
             m_scene->addNewItem(image);
             prepareTools(image);
         }
     }
     m_scene->setTool(TITLE_SELECT);
     showToolbars(TITLE_SELECT);
     checkButton(TITLE_SELECT);
 }
 
 void TitleWidget::showToolbars(TITLETOOL toolType)
 {
     toolbar_stack->setEnabled(toolType != TITLE_SELECT);
     switch (toolType) {
     case TITLE_IMAGE:
         toolbar_stack->setCurrentIndex(2);
         break;
     case TITLE_RECTANGLE:
         toolbar_stack->setCurrentIndex(1);
         break;
     case TITLE_TEXT:
     default:
         toolbar_stack->setCurrentIndex(0);
         break;
     }
 }
 
 void TitleWidget::enableToolbars(TITLETOOL toolType)
 {
     // TITLETOOL is defined in effectstack/graphicsscenerectmove.h
     bool enable = false;
     if (toolType == TITLE_RECTANGLE || toolType == TITLE_IMAGE) {
         enable = true;
     }
     value_w->setEnabled(enable);
     value_h->setEnabled(enable);
 }
 
 void TitleWidget::checkButton(TITLETOOL toolType)
 {
     bool bSelect = false;
     bool bText = false;
     bool bRect = false;
     bool bImage = false;
 
     switch (toolType) {
     case TITLE_SELECT:
         bSelect = true;
         break;
     case TITLE_TEXT:
         bText = true;
         break;
     case TITLE_RECTANGLE:
         bRect = true;
         break;
     case TITLE_IMAGE:
         bImage = true;
         break;
     default:
         break;
     }
 
     m_buttonCursor->setChecked(bSelect);
     m_buttonText->setChecked(bText);
     m_buttonRect->setChecked(bRect);
     m_buttonImage->setChecked(bImage);
 }
 
 void TitleWidget::displayBackgroundFrame()
 {
     QRectF r = m_frameBorder->sceneBoundingRect();
     if (!displayBg->isChecked()) {
         switch (KdenliveSettings::titlerbg()) {
             case 0: {
                 QPixmap pattern(20, 20);
                 pattern.fill(Qt::gray);
                 QColor bgcolor(180, 180, 180);
                 QPainter p(&pattern);
                 p.fillRect(QRect(0, 0, 10, 10), bgcolor);
                 p.fillRect(QRect(10, 10, 20, 20), bgcolor);
                 p.end();
                 QBrush br(pattern);
                 QPixmap bg((int)(r.width() / 2), (int)(r.height() / 2));
                 QPainter p2(&bg);
                 p2.fillRect(bg.rect(), br);
                 p2.end();
                 m_frameImage->setPixmap(bg);
                 break;
             }
             default: {
                 QColor col = KdenliveSettings::titlerbg() == 1 ? Qt::black : Qt::white;
                 QPixmap bg((int)(r.width() / 2), (int)(r.height() / 2));
                 QPainter p2(&bg);
                 p2.fillRect(bg.rect(), col);
                 p2.end();
                 m_frameImage->setPixmap(bg);
             }
         }
     } else {
         emit requestBackgroundFrame(true);
     }
 }
 
 void TitleWidget::slotGotBackground(const QImage &img)
 {
     QRectF r = m_frameBorder->sceneBoundingRect();
     m_frameImage->setPixmap(QPixmap::fromImage(img.scaled(r.width() / 2, r.height() / 2)));
     emit requestBackgroundFrame(false);
 }
 
 void TitleWidget::initAnimation()
 {
     align_box->setEnabled(false);
     QPen startpen(Qt::DotLine);
     QPen endpen(Qt::DashDotLine);
     startpen.setColor(QColor(100, 200, 100, 140));
     endpen.setColor(QColor(200, 100, 100, 140));
 
     m_startViewport->setPen(startpen);
     m_endViewport->setPen(endpen);
 
     m_startViewport->setZValue(-1000);
     m_endViewport->setZValue(-1000);
 
     m_startViewport->setFlags(nullptr);
     m_endViewport->setFlags(nullptr);
 
     graphicsView->scene()->addItem(m_startViewport);
     graphicsView->scene()->addItem(m_endViewport);
 
     connect(keep_aspect, &QAbstractButton::toggled, this, &TitleWidget::slotKeepAspect);
     connect(resize50, &QAbstractButton::clicked, this, &TitleWidget::slotResize50);
     connect(resize100, &QAbstractButton::clicked, this, &TitleWidget::slotResize100);
     connect(resize200, &QAbstractButton::clicked, this, &TitleWidget::slotResize200);
 }
 
 void TitleWidget::slotUpdateZoom(int pos)
 {
     zoom_spin->setValue(pos);
     zoom_slider->setValue(pos);
     m_scene->setZoom((double)pos / 100);
 }
 
 void TitleWidget::slotZoom(bool up)
 {
     int pos = zoom_slider->value();
     if (up) {
         pos++;
     } else {
         pos--;
     }
     zoom_slider->setValue(pos);
 }
 
 void TitleWidget::slotAdjustZoom()
 {
     /*double scalex = graphicsView->width() / (double)(m_frameWidth * 1.2);
     double scaley = graphicsView->height() / (double)(m_frameHeight * 1.2);
     if (scalex > scaley) scalex = scaley;
     int zoompos = (int)(scalex * 7 + 0.5);*/
     graphicsView->fitInView(m_frameBorder, Qt::KeepAspectRatio);
     int zoompos = graphicsView->matrix().m11() * 100;
     zoom_slider->setValue(zoompos);
     graphicsView->centerOn(m_frameBorder);
 }
 
 void TitleWidget::slotZoomOneToOne()
 {
     zoom_slider->setValue(100);
     graphicsView->centerOn(m_frameBorder);
 }
 
 void TitleWidget::slotNewRect(QGraphicsRectItem *rect)
 {
     updateAxisButtons(rect); // back to default
 
     if (rectLineWidth->value() == 0) {
         rect->setPen(Qt::NoPen);
     } else {
         QPen penf(rectFColor->color());
         penf.setWidth(rectLineWidth->value());
         penf.setJoinStyle(Qt::RoundJoin);
         rect->setPen(penf);
     }
     if (plain_rect->isChecked()) {
         rect->setBrush(QBrush(rectBColor->color()));
         rect->setData(TitleDocument::Gradient, QVariant());
     } else {
         // gradient
         QString gradientData = gradients_rect_combo->currentData().toString();
         rect->setData(TitleDocument::Gradient, gradientData);
         QLinearGradient gr = GradientWidget::gradientFromString(gradientData, rect->boundingRect().width(), rect->boundingRect().height());
         rect->setBrush(QBrush(gr));
     }
     rect->setZValue(m_count++);
     rect->setData(TitleDocument::ZoomFactor, 100);
     prepareTools(rect);
     // setCurrentItem(rect);
     // graphicsView->setFocus();
 }
 
 void TitleWidget::slotNewText(MyTextItem *tt)
 {
     updateAxisButtons(tt); // back to default
 
     letter_spacing->blockSignals(true);
     line_spacing->blockSignals(true);
     letter_spacing->setValue(0);
     line_spacing->setValue(0);
     letter_spacing->blockSignals(false);
     line_spacing->blockSignals(false);
     letter_spacing->setEnabled(true);
     line_spacing->setEnabled(true);
     QFont font = font_family->currentFont();
     font.setPixelSize(font_size->value());
     // mbd: issue 551:
     font.setWeight(font_weight_box->itemData(font_weight_box->currentIndex()).toInt());
     font.setItalic(buttonItalic->isChecked());
     font.setUnderline(buttonUnder->isChecked());
 
     tt->setFont(font);
     QColor color = fontColorButton->color();
     QColor outlineColor = textOutlineColor->color();
     tt->setTextColor(color);
     tt->document()->setDocumentMargin(0);
 
     QTextCursor cur(tt->document());
     cur.select(QTextCursor::Document);
     QTextBlockFormat format = cur.blockFormat();
     QTextCharFormat cformat = cur.charFormat();
     double outlineWidth = textOutline->value() / 10.0;
 
     tt->setData(TitleDocument::OutlineWidth, outlineWidth);
     tt->setData(TitleDocument::OutlineColor, outlineColor);
     if (outlineWidth > 0.0) {
         cformat.setTextOutline(QPen(outlineColor, outlineWidth));
     }
     tt->updateShadow(shadowBox->isChecked(), blur_radius->value(), shadowX->value(), shadowY->value(), shadowColor->color());
     if (gradient_color->isChecked()) {
         QString gradientData = gradients_combo->currentData().toString();
         tt->setData(TitleDocument::Gradient, gradientData);
         QLinearGradient gr = GradientWidget::gradientFromString(gradientData, tt->boundingRect().width(), tt->boundingRect().height());
         cformat.setForeground(QBrush(gr));
     } else {
         cformat.setForeground(QBrush(color));
     }
     cur.setCharFormat(cformat);
     cur.setBlockFormat(format);
     tt->setTextCursor(cur);
     tt->setZValue(m_count++);
     setCurrentItem(tt);
     prepareTools(tt);
 }
 
 void TitleWidget::setFontBoxWeight(int weight)
 {
     int index = font_weight_box->findData(weight);
     if (index < 0) {
         index = font_weight_box->findData(QFont::Normal);
     }
     font_weight_box->setCurrentIndex(index);
 }
 
 void TitleWidget::setCurrentItem(QGraphicsItem *item)
 {
     m_scene->setSelectedItem(item);
 }
 
 void TitleWidget::zIndexChanged(int v)
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     for (auto &i : l) {
         i->setZValue(v);
     }
 }
 
 void TitleWidget::selectionChanged()
 {
     if (m_scene->tool() != TITLE_SELECT) {
         return;
     }
 
     // qCDebug(KDENLIVE_LOG) << "Number of selected items: " << graphicsView->scene()->selectedItems().length() << '\n';
 
     QList<QGraphicsItem *> l;
 
     // mbt 1607: One text item might have grabbed the keyboard.
     // Ungrab it for all items that are not selected, otherwise
     // text input would only work for the text item that grabbed
     // the keyboard last.
     l = graphicsView->scene()->items();
     for (QGraphicsItem *item : l) {
         if (item->type() == TEXTITEM && !item->isSelected()) {
             auto *i = static_cast<MyTextItem *>(item);
             i->clearFocus();
         }
     }
 
     l = graphicsView->scene()->selectedItems();
 
     if (!l.isEmpty()) {
         buttonUnselectAll->setEnabled(true);
         // Enable all z index buttons if items selected.
         // We can selectively disable them later.
         zUp->setEnabled(true);
         zDown->setEnabled(true);
         zTop->setEnabled(true);
         zBottom->setEnabled(true);
     } else {
         buttonUnselectAll->setEnabled(false);
     }
     if (l.size() >= 2) {
         buttonSelectText->setEnabled(true);
         buttonSelectRects->setEnabled(true);
         buttonSelectImages->setEnabled(true);
     } else {
         buttonSelectText->setEnabled(false);
         buttonSelectRects->setEnabled(false);
         buttonSelectImages->setEnabled(false);
     }
 
     if (l.size() == 0) {
         prepareTools(nullptr);
     } else if (l.size() == 1) {
         prepareTools(l.at(0));
     } else {
         /*
         For multiple selected objects we need to decide which tools to show.
         */
         int firstType = l.at(0)->type();
         bool allEqual = true;
         for (auto i : l) {
             if (i->type() != firstType) {
                 allEqual = false;
                 break;
             }
         }
         // qCDebug(KDENLIVE_LOG) << "All equal? " << allEqual << ".\n";
         if (allEqual) {
             prepareTools(l.at(0));
         } else {
             // Get the default toolset, but enable the property frame (x,y,w,h)
             prepareTools(nullptr);
             frame_properties->setEnabled(true);
 
             // Enable x/y/w/h if it makes sense.
             value_x->setEnabled(true);
             value_y->setEnabled(true);
             bool containsTextitem = false;
             for (auto i : l) {
                 if (i->type() == TEXTITEM) {
                     containsTextitem = true;
                     break;
                 }
             }
             if (!containsTextitem) {
                 value_w->setEnabled(true);
                 value_h->setEnabled(true);
             }
         }
 
         // Disable z index buttons if they don't make sense for the current selection
         int firstZindex = l.at(0)->zValue();
         allEqual = true;
         for (auto &i : l) {
             if ((int)i->zValue() != firstZindex) {
                 allEqual = false;
                 break;
             }
         }
         if (!allEqual) {
             zUp->setEnabled(false);
             zDown->setEnabled(false);
         }
     }
 }
 
 void TitleWidget::slotValueChanged(int type)
 {
     /*
     type tells us which QSpinBox value has changed.
     */
 
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     // qCDebug(KDENLIVE_LOG) << l.size() << " items to be resized\n";
 
     // Get the updated value here already to do less coding afterwards
     int val = 0;
     switch (type) {
     case ValueWidth:
         val = value_w->value();
         break;
     case ValueHeight:
         val = value_h->value();
         break;
     case ValueX:
         val = value_x->value();
         break;
     case ValueY:
         val = value_y->value();
         break;
     }
 
     for (int k = 0; k < l.size(); ++k) {
         // qCDebug(KDENLIVE_LOG) << "Type of item " << k << ": " << l.at(k)->type() << '\n';
 
         if (l.at(k)->type() == TEXTITEM) {
             // Just update the position. We don't allow setting width/height for text items yet.
             switch (type) {
             case ValueX:
                 updatePosition(l.at(k), val, l.at(k)->pos().y());
                 break;
             case ValueY:
                 updatePosition(l.at(k), l.at(k)->pos().x(), val);
                 break;
             }
 
         } else if (l.at(k)->type() == RECTITEM) {
             auto *rec = static_cast<QGraphicsRectItem *>(l.at(k));
             switch (type) {
             case ValueX:
                 updatePosition(l.at(k), val, l.at(k)->pos().y());
                 break;
             case ValueY:
                 updatePosition(l.at(k), l.at(k)->pos().x(), val);
                 break;
             case ValueWidth:
                 rec->setRect(QRect(0, 0, val, rec->rect().height()));
                 break;
             case ValueHeight:
                 rec->setRect(QRect(0, 0, rec->rect().width(), val));
                 break;
             }
 
         } else if (l.at(k)->type() == IMAGEITEM) {
 
             if (type == ValueX) {
                 updatePosition(l.at(k), val, l.at(k)->pos().y());
 
             } else if (type == ValueY) {
                 updatePosition(l.at(k), l.at(k)->pos().x(), val);
 
             } else {
                 // Width/height has changed. This is more complex.
 
                 QGraphicsItem *i = l.at(k);
                 Transform t = m_transformations.value(i);
 
                 // Ratio width:height
                 double phi = (double)i->boundingRect().width() / i->boundingRect().height();
                 // TODO: proper calculation for rotation around 3 axes
                 double alpha = (double)t.rotatez / 180.0 * M_PI;
 
                 // New length
                 double length;
 
                 // Scaling factor
                 double scale = 1;
 
                 // We want to keep the aspect ratio of the image as the user does not yet have the possibility
                 // to restore the original ratio. You rarely want to change it anyway.
                 switch (type) {
                 case ValueWidth:
                     // Add 0.5 because otherwise incrementing by 1 might have no effect
                     length = val / (cos(alpha) + 1 / phi * sin(alpha)) + 0.5;
                     scale = length / i->boundingRect().width();
                     break;
                 case ValueHeight:
                     length = val / (phi * sin(alpha) + cos(alpha)) + 0.5;
                     scale = length / i->boundingRect().height();
                     break;
                 }
 
                 t.scalex = scale;
                 t.scaley = scale;
                 QTransform qtrans;
                 qtrans.scale(scale, scale);
                 qtrans.rotate(t.rotatex, Qt::XAxis);
                 qtrans.rotate(t.rotatey, Qt::YAxis);
                 qtrans.rotate(t.rotatez, Qt::ZAxis);
                 i->setTransform(qtrans);
                 // qCDebug(KDENLIVE_LOG) << "scale is: " << scale << '\n';
                 // qCDebug(KDENLIVE_LOG) << i->boundingRect().width() << ": new width\n";
                 m_transformations[i] = t;
 
                 if (l.size() == 1) {
                     // Only update the w/h values if the selection contains just one item.
                     // Otherwise, what should we do? ;)
                     // (Use the values of the first item? Of the second? Of the x-th?)
                     updateDimension(i);
                     // Update rotation/zoom values.
                     // These values are not yet able to handle multiple items!
                     updateRotZoom(i);
                 }
             }
         }
     }
 }
 
 void TitleWidget::updateDimension(QGraphicsItem *i)
 {
     bool wBlocked = value_w->signalsBlocked();
     bool hBlocked = value_h->signalsBlocked();
     bool zBlocked = zValue->signalsBlocked();
     value_w->blockSignals(true);
     value_h->blockSignals(true);
     zValue->blockSignals(true);
 
     zValue->setValue((int)i->zValue());
     if (i->type() == IMAGEITEM) {
         // Get multipliers for rotation/scaling
 
         /*Transform t = m_transformations.value(i);
         QRectF r = i->boundingRect();
         int width = (int) ( abs(r.width()*t.scalex * cos(t.rotate/180.0*M_PI))
                     + abs(r.height()*t.scaley * sin(t.rotate/180.0*M_PI)) );
         int height = (int) ( abs(r.height()*t.scaley * cos(t.rotate/180*M_PI))
                     + abs(r.width()*t.scalex * sin(t.rotate/180*M_PI)) );*/
 
         value_w->setValue(i->sceneBoundingRect().width());
         value_h->setValue(i->sceneBoundingRect().height());
     } else if (i->type() == RECTITEM) {
         auto *r = static_cast<QGraphicsRectItem *>(i);
         // qCDebug(KDENLIVE_LOG) << "Rect width is: " << r->rect().width() << ", was: " << value_w->value() << '\n';
         value_w->setValue((int)r->rect().width());
         value_h->setValue((int)r->rect().height());
     } else if (i->type() == TEXTITEM) {
         auto *t = static_cast<MyTextItem *>(i);
         value_w->setValue((int)t->boundingRect().width());
         value_h->setValue((int)t->boundingRect().height());
     }
 
     zValue->blockSignals(zBlocked);
     value_w->blockSignals(wBlocked);
     value_h->blockSignals(hBlocked);
 }
 
 void TitleWidget::updateCoordinates(QGraphicsItem *i)
 {
     // Block signals emitted by this method
     value_x->blockSignals(true);
     value_y->blockSignals(true);
 
     if (i->type() == TEXTITEM) {
 
         auto *rec = static_cast<MyTextItem *>(i);
 
         // Set the correct x coordinate value
         if (origin_x_left->isChecked()) {
             // Origin (0 point) is at m_frameWidth, coordinate axis is inverted
             value_x->setValue((int)(m_frameWidth - rec->pos().x() - rec->boundingRect().width()));
         } else {
             // Origin is at 0 (default)
             value_x->setValue((int)rec->pos().x());
         }
 
         // Same for y
         if (origin_y_top->isChecked()) {
             value_y->setValue((int)(m_frameHeight - rec->pos().y() - rec->boundingRect().height()));
         } else {
             value_y->setValue((int)rec->pos().y());
         }
 
     } else if (i->type() == RECTITEM) {
 
         auto *rec = static_cast<QGraphicsRectItem *>(i);
 
         if (origin_x_left->isChecked()) {
             // Origin (0 point) is at m_frameWidth
             value_x->setValue((int)(m_frameWidth - rec->pos().x() - rec->rect().width()));
         } else {
             // Origin is at 0 (default)
             value_x->setValue((int)rec->pos().x());
         }
 
         if (origin_y_top->isChecked()) {
             value_y->setValue((int)(m_frameHeight - rec->pos().y() - rec->rect().height()));
         } else {
             value_y->setValue((int)rec->pos().y());
         }
 
     } else if (i->type() == IMAGEITEM) {
 
         if (origin_x_left->isChecked()) {
             value_x->setValue((int)(m_frameWidth - i->pos().x() - i->sceneBoundingRect().width()));
         } else {
             value_x->setValue((int)i->pos().x());
         }
 
         if (origin_y_top->isChecked()) {
             value_y->setValue((int)(m_frameHeight - i->pos().y() - i->sceneBoundingRect().height()));
         } else {
             value_y->setValue((int)i->pos().y());
         }
     }
 
     // Stop blocking signals now
     value_x->blockSignals(false);
     value_y->blockSignals(false);
 }
 
 void TitleWidget::updateRotZoom(QGraphicsItem *i)
 {
     itemzoom->blockSignals(true);
     itemrotatex->blockSignals(true);
     itemrotatey->blockSignals(true);
     itemrotatez->blockSignals(true);
 
     Transform t = m_transformations.value(i);
 
     if (!i->data(TitleDocument::ZoomFactor).isNull()) {
         itemzoom->setValue(i->data(TitleDocument::ZoomFactor).toInt());
     } else {
         itemzoom->setValue((int)(t.scalex * 100.0 + 0.5));
     }
 
     itemrotatex->setValue((int)(t.rotatex));
     itemrotatey->setValue((int)(t.rotatey));
     itemrotatez->setValue((int)(t.rotatez));
 
     itemzoom->blockSignals(false);
     itemrotatex->blockSignals(false);
     itemrotatey->blockSignals(false);
     itemrotatez->blockSignals(false);
 }
 
 void TitleWidget::updatePosition(QGraphicsItem *i)
 {
     updatePosition(i, value_x->value(), value_y->value());
 }
 
 void TitleWidget::updatePosition(QGraphicsItem *i, int x, int y)
 {
     if (i->type() == TEXTITEM) {
         auto *rec = static_cast<MyTextItem *>(i);
 
         int posX;
         if (origin_x_left->isChecked()) {
             /*
              * Origin of the X axis is at m_frameWidth, and distance from right
              * border of the item to the right border of the frame is taken. See
              * comment to slotOriginXClicked().
              */
             posX = m_frameWidth - x - rec->boundingRect().width();
         } else {
             posX = x;
         }
 
         int posY;
         if (origin_y_top->isChecked()) {
             /* Same for y axis */
             posY = m_frameHeight - y - rec->boundingRect().height();
         } else {
             posY = y;
         }
 
         rec->setPos(posX, posY);
 
     } else if (i->type() == RECTITEM) {
 
         auto *rec = static_cast<QGraphicsRectItem *>(i);
 
         int posX;
         if (origin_x_left->isChecked()) {
             posX = m_frameWidth - x - rec->rect().width();
         } else {
             posX = x;
         }
 
         int posY;
         if (origin_y_top->isChecked()) {
             posY = m_frameHeight - y - rec->rect().height();
         } else {
             posY = y;
         }
 
         rec->setPos(posX, posY);
 
     } else if (i->type() == IMAGEITEM) {
         int posX;
         if (origin_x_left->isChecked()) {
             // Use the sceneBoundingRect because this also regards transformations like zoom
             posX = m_frameWidth - x - i->sceneBoundingRect().width();
         } else {
             posX = x;
         }
 
         int posY;
         if (origin_y_top->isChecked()) {
             posY = m_frameHeight - y - i->sceneBoundingRect().height();
         } else {
             posY = y;
         }
 
         i->setPos(posX, posY);
     }
 }
 
 void TitleWidget::updateTextOriginX()
 {
     if (origin_x_left->isChecked()) {
         origin_x_left->setText(i18n("\u2212X"));
     } else {
         origin_x_left->setText(i18n("+X"));
     }
 }
 
 void TitleWidget::slotOriginXClicked()
 {
     // Update the text displayed on the button.
     updateTextOriginX();
 
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() >= 1) {
         updateCoordinates(l.at(0));
 
         // Remember x axis setting
         l.at(0)->setData(TitleDocument::OriginXLeft, origin_x_left->isChecked() ? TitleDocument::AxisInverted : TitleDocument::AxisDefault);
     }
     graphicsView->setFocus();
 }
 
 void TitleWidget::updateTextOriginY()
 {
     if (origin_y_top->isChecked()) {
         origin_y_top->setText(i18n("\u2212Y"));
     } else {
         origin_y_top->setText(i18n("+Y"));
     }
 }
 
 void TitleWidget::slotOriginYClicked()
 {
     // Update the text displayed on the button.
     updateTextOriginY();
 
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() >= 1) {
         updateCoordinates(l.at(0));
 
         l.at(0)->setData(TitleDocument::OriginYTop, origin_y_top->isChecked() ? TitleDocument::AxisInverted : TitleDocument::AxisDefault);
     }
     graphicsView->setFocus();
 }
 
 void TitleWidget::updateAxisButtons(QGraphicsItem *i)
 {
     int xAxis = i->data(TitleDocument::OriginXLeft).toInt();
     int yAxis = i->data(TitleDocument::OriginYTop).toInt();
     origin_x_left->blockSignals(true);
     origin_y_top->blockSignals(true);
 
     if (xAxis == TitleDocument::AxisInverted) {
         origin_x_left->setChecked(true);
     } else {
         origin_x_left->setChecked(false);
     }
     updateTextOriginX();
 
     if (yAxis == TitleDocument::AxisInverted) {
         origin_y_top->setChecked(true);
     } else {
         origin_y_top->setChecked(false);
     }
     updateTextOriginY();
 
     origin_x_left->blockSignals(false);
     origin_y_top->blockSignals(false);
 }
 
 void TitleWidget::slotChangeBackground()
 {
     QColor color = backgroundColor->color();
     m_scene->setBackgroundBrush(QBrush(color));
     color.setAlpha(backgroundAlpha->value());
     m_frameBackground->setBrush(QBrush(color));
 }
 
 void TitleWidget::slotChanged()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() >= 1 && l.at(0)->type() == TEXTITEM) {
         textChanged(static_cast<MyTextItem *>(l.at(0)));
     }
 }
 
 void TitleWidget::textChanged(MyTextItem *i)
 {
     /*
      * If the user has set origin_x_left (the same for y), we need to look
      * whether a text element has been selected. If yes, we need to ensure that
      * the right border of the text field remains fixed also when some text has
      * been entered.
      *
      * This is also known as right-justified, with the difference that it is not
      * valid for text but for its boundingRect. Text may still be
      * left-justified.
      */
     updateDimension(i);
 
     if (origin_x_left->isChecked() || origin_y_top->isChecked()) {
         if (!i->document()->isEmpty()) {
             updatePosition(i);
         } else {
             /*
              * Don't do anything if the string is empty. If the position were
              * updated here, a newly created text field would be set to the
              * position of the last selected text field.
              */
         }
     }
 
     // mbt 1607: Template text has changed; don't auto-select content anymore.
     if (i->property("isTemplate").isValid()) {
         if (i->property("templateText").isValid()) {
             if (i->property("templateText") == i->toHtml()) {
                 // Unchanged, do nothing.
             } else {
                 i->setProperty("isTemplate", QVariant::Invalid);
                 i->setProperty("templateText", QVariant::Invalid);
             }
         }
     }
 }
 
 void TitleWidget::slotInsertUnicode()
 {
     m_unicodeDialog->exec();
 }
 
 void TitleWidget::slotInsertUnicodeString(const QString &string)
 {
     const QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (!l.isEmpty()) {
         if (l.at(0)->type() == TEXTITEM) {
             auto *t = static_cast<MyTextItem *>(l.at(0));
             t->textCursor().insertText(string);
         }
     }
 }
 
 void TitleWidget::slotUpdateText()
 {
     QFont font = font_family->currentFont();
     font.setPixelSize(font_size->value());
     font.setItalic(buttonItalic->isChecked());
     font.setUnderline(buttonUnder->isChecked());
     font.setWeight(font_weight_box->itemData(font_weight_box->currentIndex()).toInt());
     font.setLetterSpacing(QFont::AbsoluteSpacing, letter_spacing->value());
     QColor color = fontColorButton->color();
     QColor outlineColor = textOutlineColor->color();
     QString gradientData;
     if (gradient_color->isChecked()) {
         // user wants a gradient
         gradientData = gradients_combo->currentData().toString();
     }
 
     double outlineWidth = textOutline->value() / 10.0;
 
     int i;
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     for (i = 0; i < l.length(); ++i) {
         MyTextItem *item = nullptr;
         if (l.at(i)->type() == TEXTITEM) {
             item = static_cast<MyTextItem *>(l.at(i));
         }
         if (!item) {
             // No text item, try next one.
             continue;
         }
 
         // Set alignment of all text in the text item
         QTextCursor cur(item->document());
         cur.select(QTextCursor::Document);
         QTextBlockFormat format = cur.blockFormat();
         item->setData(TitleDocument::LineSpacing, line_spacing->value());
         format.setLineHeight(line_spacing->value(), QTextBlockFormat::LineDistanceHeight);
         if (buttonAlignLeft->isChecked() || buttonAlignCenter->isChecked() || buttonAlignRight->isChecked()) {
             if (buttonAlignCenter->isChecked()) {
                 item->setAlignment(Qt::AlignHCenter);
             } else if (buttonAlignRight->isChecked()) {
                 item->setAlignment(Qt::AlignRight);
             } else if (buttonAlignLeft->isChecked()) {
                 item->setAlignment(Qt::AlignLeft);
             }
         } else {
             item->setAlignment(qApp->isLeftToRight() ? Qt::AlignRight : Qt::AlignLeft);
         }
 
         // Set font properties
         item->setFont(font);
         QTextCharFormat cformat = cur.charFormat();
 
         item->setData(TitleDocument::OutlineWidth, outlineWidth);
         item->setData(TitleDocument::OutlineColor, outlineColor);
         if (outlineWidth > 0.0) {
             cformat.setTextOutline(QPen(outlineColor, outlineWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
         }
 
         if (gradientData.isEmpty()) {
             cformat.setForeground(QBrush(color));
         } else {
             QLinearGradient gr = GradientWidget::gradientFromString(gradientData, item->boundingRect().width(), item->boundingRect().height());
             cformat.setForeground(QBrush(gr));
         }
         // Store gradient in item properties
         item->setData(TitleDocument::Gradient, gradientData);
         cur.setCharFormat(cformat);
         cur.setBlockFormat(format);
         //  item->setTextCursor(cur);
         cur.clearSelection();
         item->setTextCursor(cur);
         item->setTextColor(color);
     }
 }
 
 void TitleWidget::rectChanged()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     for (auto i : l) {
         if (i->type() == RECTITEM && (settingUp == 0)) {
             auto *rec = static_cast<QGraphicsRectItem *>(i);
             QColor f = rectFColor->color();
             if (rectLineWidth->value() == 0) {
                 rec->setPen(Qt::NoPen);
             } else {
                 QPen penf(f);
                 penf.setWidth(rectLineWidth->value());
                 penf.setJoinStyle(Qt::RoundJoin);
                 rec->setPen(penf);
             }
             if (plain_rect->isChecked()) {
                 rec->setBrush(QBrush(rectBColor->color()));
                 rec->setData(TitleDocument::Gradient, QVariant());
             } else {
                 // gradient
                 QString gradientData = gradients_rect_combo->currentData().toString();
                 rec->setData(TitleDocument::Gradient, gradientData);
                 QLinearGradient gr = GradientWidget::gradientFromString(gradientData, rec->boundingRect().width(), rec->boundingRect().height());
                 rec->setBrush(QBrush(gr));
             }
         }
     }
 }
 
 void TitleWidget::itemScaled(int val)
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         Transform x = m_transformations.value(l.at(0));
         x.scalex = (double)val / 100.0;
         x.scaley = (double)val / 100.0;
         QTransform qtrans;
         qtrans.scale(x.scalex, x.scaley);
         qtrans.rotate(x.rotatex, Qt::XAxis);
         qtrans.rotate(x.rotatey, Qt::YAxis);
         qtrans.rotate(x.rotatez, Qt::ZAxis);
         l[0]->setTransform(qtrans);
         l[0]->setData(TitleDocument::ZoomFactor, val);
         m_transformations[l.at(0)] = x;
         updateDimension(l.at(0));
     }
 }
 
 void TitleWidget::itemRotateX(int val)
 {
     itemRotate(val, 0);
 }
 
 void TitleWidget::itemRotateY(int val)
 {
     itemRotate(val, 1);
 }
 
 void TitleWidget::itemRotateZ(int val)
 {
     itemRotate(val, 2);
 }
 
 void TitleWidget::itemRotate(int val, int axis)
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         Transform x = m_transformations[l.at(0)];
         switch (axis) {
         case 0:
             x.rotatex = val;
             break;
         case 1:
             x.rotatey = val;
             break;
         case 2:
             x.rotatez = val;
             break;
         }
 
         l[0]->setData(TitleDocument::RotateFactor, QList<QVariant>() << QVariant(x.rotatex) << QVariant(x.rotatey) << QVariant(x.rotatez));
 
         QTransform qtrans;
         qtrans.scale(x.scalex, x.scaley);
         qtrans.rotate(x.rotatex, Qt::XAxis);
         qtrans.rotate(x.rotatey, Qt::YAxis);
         qtrans.rotate(x.rotatez, Qt::ZAxis);
         l[0]->setTransform(qtrans);
         m_transformations[l.at(0)] = x;
         if (l[0]->data(TitleDocument::ZoomFactor).isNull()) {
             l[0]->setData(TitleDocument::ZoomFactor, 100);
         }
         updateDimension(l.at(0));
     }
 }
 
 void TitleWidget::itemHCenter()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QGraphicsItem *item = l.at(0);
         QRectF br = item->sceneBoundingRect();
         int width = (int)br.width();
         int newPos = (int)((m_frameWidth - width) / 2);
         newPos += item->pos().x() - br.left(); // Check item transformation
         item->setPos(newPos, item->pos().y());
         updateCoordinates(item);
     }
 }
 
 void TitleWidget::itemVCenter()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QGraphicsItem *item = l.at(0);
         QRectF br = item->sceneBoundingRect();
         int height = (int)br.height();
         int newPos = (int)((m_frameHeight - height) / 2);
         newPos += item->pos().y() - br.top(); // Check item transformation
         item->setPos(item->pos().x(), newPos);
         updateCoordinates(item);
     }
 }
 
 void TitleWidget::itemTop()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QList <double> margins {m_frameHeight * 0.05, m_frameHeight * 0.1};
         QGraphicsItem *item = l.at(0);
         QRectF br = item->sceneBoundingRect();
         double diff;
         if (br.top() < 0.) {
             // align with big margin
             diff = margins.at(1) - br.top();
         } else if (qFuzzyIsNull(br.top())) {
             // align right with frame border
             diff = - br.bottom();
         } else if (br.top() <= margins.at(0)) {
             // align with 0
             diff = - br.top();
         } else if (br.top() <= margins.at(1)) {
             // align with small margin
             diff = margins.at(0) - br.top();
         } else {
             // align with big margin
             diff = margins.at(1) - br.top();
         }
         item->moveBy(0, diff);
         updateCoordinates(item);
     }
 }
 
 void TitleWidget::itemBottom()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QList <double> margins {m_frameHeight * 0.9, m_frameHeight* 0.95};
         QGraphicsItem *item = l.at(0);
         QRectF br = item->sceneBoundingRect();
         double diff;
         if (br.bottom() < margins.at(0)) {
             // align with small margin
             diff = margins.at(0) - br.bottom();
         } else if (br.bottom() < margins.at(1)) {
             // align big margin
             diff = margins.at(1) - br.bottom();
         } else if (br.bottom() < m_frameHeight) {
             // align with frame
             diff = m_frameHeight - br.bottom();
         } else if (br.top() < m_frameHeight) {
             // align left with frame
             diff = m_frameHeight - br.top();
         } else {
             // align with big margin
             diff = margins.at(0) - br.bottom();
         }
         item->moveBy(0, diff);
         updateCoordinates(item);
     }
 }
 
 void TitleWidget::itemLeft()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QList <double> margins {m_frameWidth * 0.05, m_frameWidth * 0.1};
         QGraphicsItem *item = l.at(0);
         QRectF br = item->sceneBoundingRect();
         double diff;
         if (br.left() < 0.) {
             // align with big margin
             diff = margins.at(1) - br.left();
         } else if (qFuzzyIsNull(br.left())) {
             // align right with frame border
             diff = - br.right();
         } else if (br.left() <= margins.at(0)) {
             // align with 0
             diff = - br.left();
         } else if (br.left() <= margins.at(1)) {
             // align with small margin
             diff = margins.at(0) - br.left();
         } else {
             // align with big margin
             diff = margins.at(1) - br.left();
         }
         item->moveBy(diff, 0);
         updateCoordinates(item);
     }
 }
 
 void TitleWidget::itemRight()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QList <double> margins {m_frameWidth * 0.9, m_frameWidth * 0.95};
         QGraphicsItem *item = l.at(0);
         QRectF br = item->sceneBoundingRect();
         double diff;
         if (br.right() < margins.at(0)) {
             // align with small margin
             diff = margins.at(0) - br.right();
         } else if (br.right() < margins.at(1)) {
             // align big margin
             diff = margins.at(1) - br.right();
         } else if (br.right() < m_frameWidth) {
             // align with frame
             diff = m_frameWidth - br.right();
         } else if (br.left() < m_frameWidth) {
             // align left with frame
             diff = m_frameWidth - br.left();
         } else {
             // align with big margin
             diff = margins.at(0) - br.right();
         }
         item->moveBy(diff, 0);
         updateCoordinates(item);
     }
 }
 
 void TitleWidget::loadTitle(QUrl url)
 {
     if (!url.isValid()) {
         QString startFolder = KRecentDirs::dir(QStringLiteral(":KdenliveProjectsTitles"));
         url = QFileDialog::getOpenFileUrl(this, i18n("Load Title"), QUrl::fromLocalFile(startFolder.isEmpty() ? m_projectTitlePath : startFolder),
                                           i18n("Kdenlive title (*.kdenlivetitle)"));
     }
     if (url.isValid()) {
         // make sure we don't delete the guides
         qDeleteAll(m_guides);
         m_guides.clear();
         QList<QGraphicsItem *> items = m_scene->items();
         items.removeAll(m_frameBorder);
         items.removeAll(m_frameBackground);
         items.removeAll(m_frameImage);
         for (auto item : items) {
             if (item->zValue() > -1000) {
                 delete item;
             }
         }
         m_scene->clearTextSelection();
         QDomDocument doc;
         QFile file(url.toLocalFile());
         doc.setContent(&file, false);
         file.close();
         setXml(doc);
         updateGuides(0);
         m_projectTitlePath = QFileInfo(file).dir().absolutePath();
         KRecentDirs::add(QStringLiteral(":KdenliveProjectsTitles"), m_projectTitlePath);
     }
 }
 
 void TitleWidget::saveTitle(QUrl url)
 {
     if (anim_start->isChecked()) {
         slotAnimStart(false);
     }
     if (anim_end->isChecked()) {
         slotAnimEnd(false);
     }
     bool embed_image = false;
 
     // If we have images in the title, ask for embed
     QList<QGraphicsItem *> list = graphicsView->scene()->items();
     QGraphicsPixmapItem pix;
     int pixmapType = pix.type();
     for (const QGraphicsItem *item : list) {
         if (item->type() == pixmapType && item != m_frameImage) {
             embed_image = true;
             break;
         }
     }
     if (embed_image && KMessageBox::questionYesNo(
                            this, i18n("Do you want to embed Images into this TitleDocument?\nThis is most needed for sharing Titles.")) != KMessageBox::Yes) {
         embed_image = false;
     }
     if (!url.isValid()) {
         QPointer<QFileDialog> fs = new QFileDialog(this, i18n("Save Title"), m_projectTitlePath);
         fs->setMimeTypeFilters(QStringList() << QStringLiteral("application/x-kdenlivetitle"));
         fs->setFileMode(QFileDialog::AnyFile);
         fs->setAcceptMode(QFileDialog::AcceptSave);
         fs->setDefaultSuffix(QStringLiteral("kdenlivetitle"));
 
         // TODO: KF5 porting?
         // fs->setConfirmOverwrite(true);
         // fs->setKeepLocation(true);
         if ((fs->exec() != 0) && !fs->selectedUrls().isEmpty()) {
             url = fs->selectedUrls().constFirst();
         }
         delete fs;
     }
     if (url.isValid()) {
         if (!m_titledocument.saveDocument(url, m_startViewport, m_endViewport, m_tc.getFrameCount(title_duration->text()), embed_image)) {
             KMessageBox::error(this, i18n("Cannot write to file %1", url.toLocalFile()));
         }
     }
 }
 
 void TitleWidget::downloadTitleTemplates()
 {
     if (getNewStuff(QStringLiteral(":data/kdenlive_titles.knsrc")) > 0) {
         refreshTitleTemplates(m_projectTitlePath);
         refreshTemplateBoxContents();
     }
 }
 
 int TitleWidget::getNewStuff(const QString &configFile)
 {
     KNS3::Entry::List entries;
     QPointer<KNS3::DownloadDialog> dialog = new KNS3::DownloadDialog(configFile);
     if (dialog->exec() != 0) {
         entries = dialog->changedEntries();
     }
     for (const KNS3::Entry &entry : entries) {
         if (entry.status() == KNS3::Entry::Installed) {
             qCDebug(KDENLIVE_LOG) << "// Installed files: " << entry.installedFiles();
         }
     }
     delete dialog;
     return entries.size();
 }
 
 QDomDocument TitleWidget::xml()
 {
     QDomDocument doc = m_titledocument.xml(m_startViewport, m_endViewport);
     int duration = m_tc.getFrameCount(title_duration->text());
     doc.documentElement().setAttribute(QStringLiteral("duration"), duration);
     doc.documentElement().setAttribute(QStringLiteral("out"), duration - 1);
     return doc;
 }
 
 int TitleWidget::duration() const
 {
     return m_tc.getFrameCount(title_duration->text());
 }
 
 void TitleWidget::setXml(const QDomDocument &doc, const QString &id)
 {
     m_clipId = id;
     int duration;
     if (m_missingMessage) {
         delete m_missingMessage;
         m_missingMessage = nullptr;
     }
     m_count = m_titledocument.loadFromXml(doc, m_startViewport, m_endViewport, &duration, m_projectTitlePath);
     adjustFrameSize();
     if (m_titledocument.invalidCount() > 0) {
         m_missingMessage = new KMessageWidget(this);
         m_missingMessage->setCloseButtonVisible(true);
         m_missingMessage->setWordWrap(true);
         m_missingMessage->setMessageType(KMessageWidget::Warning);
         m_missingMessage->setText(i18np("This title has 1 missing element", "This title has %1 missing elements", m_titledocument.invalidCount()));
         QAction *action = new QAction(i18n("Details"));
         m_missingMessage->addAction(action);
         connect(action, &QAction::triggered, this, &TitleWidget::showMissingItems);
         action = new QAction(i18n("Delete missing elements"));
         m_missingMessage->addAction(action);
         connect(action, &QAction::triggered, this, &TitleWidget::deleteMissingItems);
         messageLayout->addWidget(m_missingMessage);
         m_missingMessage->animatedShow();
     }
     title_duration->setText(m_tc.getTimecode(GenTime(duration, m_fps)));
     /*if (doc.documentElement().hasAttribute("out")) {
     GenTime duration = GenTime(doc.documentElement().attribute("out").toDouble() / 1000.0);
     title_duration->setText(m_tc.getTimecode(duration));
     }
     else title_duration->setText(m_tc.getTimecode(GenTime(5000)));*/
 
     QDomElement e = doc.documentElement();
     m_transformations.clear();
     QList<QGraphicsItem *> items = graphicsView->scene()->items();
     const double PI = 4.0 * atan(1.0);
     for (int i = 0; i < items.count(); ++i) {
         QTransform t = items.at(i)->transform();
         Transform x;
         x.scalex = t.m11();
         x.scaley = t.m22();
         if (!items.at(i)->data(TitleDocument::RotateFactor).isNull()) {
             QList<QVariant> rotlist = items.at(i)->data(TitleDocument::RotateFactor).toList();
             if (rotlist.count() >= 3) {
                 x.rotatex = rotlist[0].toDouble();
                 x.rotatey = rotlist[1].toDouble();
                 x.rotatez = rotlist[2].toDouble();
 
                 // Try to adjust zoom
                 t.rotate(x.rotatex * (-1), Qt::XAxis);
                 t.rotate(x.rotatey * (-1), Qt::YAxis);
                 t.rotate(x.rotatez * (-1), Qt::ZAxis);
                 x.scalex = t.m11();
                 x.scaley = t.m22();
             } else {
                 x.rotatex = 0;
                 x.rotatey = 0;
                 x.rotatez = 0;
             }
         } else {
             x.rotatex = 0;
             x.rotatey = 0;
             x.rotatez = 180. / PI * atan2(-t.m21(), t.m11());
         }
         m_transformations[items.at(i)] = x;
     }
     // mbd: Update the GUI color selectors to match the stuff from the loaded document
     QColor background_color = m_titledocument.getBackgroundColor();
     backgroundAlpha->blockSignals(true);
     backgroundColor->blockSignals(true);
     backgroundAlpha->setValue(background_color.alpha());
     background_color.setAlpha(255);
     backgroundColor->setColor(background_color);
     backgroundAlpha->blockSignals(false);
     backgroundColor->blockSignals(false);
 
     /*startViewportX->setValue(m_startViewport->data(0).toInt());
     startViewportY->setValue(m_startViewport->data(1).toInt());
     startViewportSize->setValue(m_startViewport->data(2).toInt());
     endViewportX->setValue(m_endViewport->data(0).toInt());
     endViewportY->setValue(m_endViewport->data(1).toInt());
     endViewportSize->setValue(m_endViewport->data(2).toInt());*/
 
     QTimer::singleShot(200, this, &TitleWidget::slotAdjustZoom);
     slotSelectTool();
     selectionChanged();
 }
 
 void TitleWidget::slotAccepted()
 {
     if (anim_start->isChecked()) {
         slotAnimStart(false);
     }
     if (anim_end->isChecked()) {
         slotAnimEnd(false);
     }
     writeChoices();
 }
 
 void TitleWidget::deleteMissingItems()
 {
     m_missingMessage->animatedHide();
     QList<QGraphicsItem *> items = graphicsView->scene()->items();
     QList<QGraphicsItem *> toDelete;
     for (int i = 0; i < items.count(); ++i) {
         if (items.at(i)->data(Qt::UserRole + 2).toInt() == 1) {
             // We found a missing item
             toDelete << items.at(i);
         }
     }
     if (toDelete.size() != m_titledocument.invalidCount()) {
         qDebug() << "/// WARNING, INCOHERENT MISSING ELEMENTS in title: " << toDelete.size() << " != " << m_titledocument.invalidCount();
     }
     while (!toDelete.isEmpty()) {
         QGraphicsItem *item = toDelete.takeFirst();
         if (m_scene) {
             m_scene->removeItem(item);
         }
     }
     m_missingMessage->deleteLater();
 }
 
 void TitleWidget::showMissingItems()
 {
     QList<QGraphicsItem *> items = graphicsView->scene()->items();
     QStringList missingUrls;
     for (int i = 0; i < items.count(); ++i) {
         if (items.at(i)->data(Qt::UserRole + 2).toInt() == 1) {
             // We found a missing item
             missingUrls << items.at(i)->data(Qt::UserRole).toString();
         }
     }
     missingUrls.removeDuplicates();
     KMessageBox::informationList(QApplication::activeWindow(), i18n("The following files are missing:"), missingUrls);
 }
 
 void TitleWidget::writeChoices()
 {
     // Get a pointer to a shared configuration instance, then get the TitleWidget group.
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup titleConfig(config, "TitleWidget");
     // Write the entries
     titleConfig.writeEntry("dialog_geometry", saveGeometry().toBase64());
     titleConfig.writeEntry("font_family", font_family->currentFont());
     // titleConfig.writeEntry("font_size", font_size->value());
     titleConfig.writeEntry("font_pixel_size", font_size->value());
     titleConfig.writeEntry("font_color", fontColorButton->color());
     titleConfig.writeEntry("font_outline_color", textOutlineColor->color());
     titleConfig.writeEntry("font_outline", textOutline->value());
     titleConfig.writeEntry("font_weight", font_weight_box->itemData(font_weight_box->currentIndex()).toInt());
     titleConfig.writeEntry("font_italic", buttonItalic->isChecked());
     titleConfig.writeEntry("font_underlined", buttonUnder->isChecked());
 
     titleConfig.writeEntry("rect_background_color", rectBColor->color());
     titleConfig.writeEntry("rect_foreground_color", rectFColor->color());
 
     titleConfig.writeEntry("rect_background_alpha", rectBColor->color().alpha());
     titleConfig.writeEntry("rect_foreground_alpha", rectFColor->color().alpha());
 
     titleConfig.writeEntry("rect_line_width", rectLineWidth->value());
 
     titleConfig.writeEntry("background_color", backgroundColor->color());
     titleConfig.writeEntry("background_alpha", backgroundAlpha->value());
 
     titleConfig.writeEntry("use_grid", use_grid->isChecked());
 
     //! \todo Not sure if I should sync - it is probably safe to do it
     config->sync();
 }
 
 void TitleWidget::readChoices()
 {
     // Get a pointer to a shared configuration instance, then get the TitleWidget group.
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup titleConfig(config, "TitleWidget");
     // read the entries
     const QByteArray geometry = titleConfig.readEntry("dialog_geometry", QByteArray());
     restoreGeometry(QByteArray::fromBase64(geometry));
     font_family->setCurrentFont(titleConfig.readEntry("font_family", font_family->currentFont()));
     font_size->setValue(titleConfig.readEntry("font_pixel_size", m_frameHeight > 0 ? (int)(m_frameHeight / 20): font_size->value()));
     m_scene->slotUpdateFontSize(font_size->value());
     QColor fontColor = QColor(titleConfig.readEntry("font_color", fontColorButton->color()));
     QColor outlineColor = QColor(titleConfig.readEntry("font_outline_color", textOutlineColor->color()));
     fontColor.setAlpha(titleConfig.readEntry("font_alpha", fontColor.alpha()));
     outlineColor.setAlpha(titleConfig.readEntry("font_outline_alpha", outlineColor.alpha()));
     fontColorButton->setColor(fontColor);
     textOutlineColor->setColor(outlineColor);
     textOutline->setValue(titleConfig.readEntry("font_outline", textOutline->value()));
 
     int weight;
     if (titleConfig.readEntry("font_bold", false)) {
         weight = QFont::Bold;
     } else {
         weight = titleConfig.readEntry("font_weight", font_weight_box->itemData(font_weight_box->currentIndex()).toInt());
     }
     setFontBoxWeight(weight);
     buttonItalic->setChecked(titleConfig.readEntry("font_italic", buttonItalic->isChecked()));
     buttonUnder->setChecked(titleConfig.readEntry("font_underlined", buttonUnder->isChecked()));
 
     QColor fgColor = QColor(titleConfig.readEntry("rect_foreground_color", rectFColor->color()));
     QColor bgColor = QColor(titleConfig.readEntry("rect_background_color", rectBColor->color()));
 
     fgColor.setAlpha(titleConfig.readEntry("rect_foreground_alpha", fgColor.alpha()));
     bgColor.setAlpha(titleConfig.readEntry("rect_background_alpha", bgColor.alpha()));
     rectFColor->setColor(fgColor);
     rectBColor->setColor(bgColor);
 
     rectLineWidth->setValue(titleConfig.readEntry("rect_line_width", rectLineWidth->value()));
 
     backgroundColor->setColor(titleConfig.readEntry("background_color", backgroundColor->color()));
     backgroundAlpha->setValue(titleConfig.readEntry("background_alpha", backgroundAlpha->value()));
     use_grid->setChecked(titleConfig.readEntry("use_grid", false));
     m_scene->slotUseGrid(use_grid->isChecked());
 }
 
 void TitleWidget::adjustFrameSize()
 {
     m_frameWidth = m_titledocument.frameWidth();
     m_frameHeight = m_titledocument.frameHeight();
     m_frameBorder->setRect(0, 0, m_frameWidth, m_frameHeight);
     displayBackgroundFrame();
 }
 
 void TitleWidget::slotAnimStart(bool anim)
 {
     if (anim && anim_end->isChecked()) {
         anim_end->setChecked(false);
         m_endViewport->setZValue(-1000);
         m_endViewport->setBrush(QBrush());
     }
     slotSelectTool();
     QList<QGraphicsItem *> list = m_scene->items();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->zValue() > -1000) {
             if (!list.at(i)->data(-1).isNull()) {
                 continue;
             }
             list.at(i)->setFlag(QGraphicsItem::ItemIsMovable, !anim);
             list.at(i)->setFlag(QGraphicsItem::ItemIsSelectable, !anim);
         }
     }
     align_box->setEnabled(anim);
     itemzoom->setEnabled(!anim);
     itemrotatex->setEnabled(!anim);
     itemrotatey->setEnabled(!anim);
     itemrotatez->setEnabled(!anim);
     frame_toolbar->setEnabled(!anim);
     toolbar_stack->setEnabled(!anim);
     if (anim) {
         keep_aspect->setChecked(!m_startViewport->data(0).isNull());
         m_startViewport->setZValue(1100);
         QColor col = m_startViewport->pen().color();
         col.setAlpha(100);
         m_startViewport->setBrush(col);
         m_startViewport->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
         m_startViewport->setSelected(true);
         selectionChanged();
         slotSelectTool();
         if (m_startViewport->childItems().isEmpty()) {
             addAnimInfoText();
         }
     } else {
         m_startViewport->setZValue(-1000);
         m_startViewport->setBrush(QBrush());
         m_startViewport->setFlags(nullptr);
         if (!anim_end->isChecked()) {
             deleteAnimInfoText();
         }
     }
 }
 
 void TitleWidget::slotAnimEnd(bool anim)
 {
     if (anim && anim_start->isChecked()) {
         anim_start->setChecked(false);
         m_startViewport->setZValue(-1000);
         m_startViewport->setBrush(QBrush());
     }
     slotSelectTool();
     QList<QGraphicsItem *> list = m_scene->items();
     for (int i = 0; i < list.count(); ++i) {
         if (list.at(i)->zValue() > -1000) {
             if (!list.at(i)->data(-1).isNull()) {
                 continue;
             }
             list.at(i)->setFlag(QGraphicsItem::ItemIsMovable, !anim);
             list.at(i)->setFlag(QGraphicsItem::ItemIsSelectable, !anim);
         }
     }
     align_box->setEnabled(anim);
     itemzoom->setEnabled(!anim);
     itemrotatex->setEnabled(!anim);
     itemrotatey->setEnabled(!anim);
     itemrotatez->setEnabled(!anim);
     frame_toolbar->setEnabled(!anim);
     toolbar_stack->setEnabled(!anim);
     if (anim) {
         keep_aspect->setChecked(!m_endViewport->data(0).isNull());
         m_endViewport->setZValue(1100);
         QColor col = m_endViewport->pen().color();
         col.setAlpha(100);
         m_endViewport->setBrush(col);
         m_endViewport->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
         m_endViewport->setSelected(true);
         selectionChanged();
         slotSelectTool();
         if (m_endViewport->childItems().isEmpty()) {
             addAnimInfoText();
         }
     } else {
         m_endViewport->setZValue(-1000);
         m_endViewport->setBrush(QBrush());
         m_endViewport->setFlags(nullptr);
         if (!anim_start->isChecked()) {
             deleteAnimInfoText();
         }
     }
 }
 
 void TitleWidget::addAnimInfoText()
 {
     // add text to anim viewport
     QGraphicsTextItem *t = new QGraphicsTextItem(i18nc("Indicates the start of an animation", "Start"), m_startViewport);
     QGraphicsTextItem *t2 = new QGraphicsTextItem(i18nc("Indicates the end of an animation", "End"), m_endViewport);
     QFont font = t->font();
     font.setPixelSize(m_startViewport->rect().width() / 10);
     QColor col = m_startViewport->pen().color();
     col.setAlpha(255);
     t->setDefaultTextColor(col);
     t->setFont(font);
     font.setPixelSize(m_endViewport->rect().width() / 10);
     col = m_endViewport->pen().color();
     col.setAlpha(255);
     t2->setDefaultTextColor(col);
     t2->setFont(font);
 }
 
 void TitleWidget::updateInfoText()
 {
     // update info text font
     if (!m_startViewport->childItems().isEmpty()) {
         MyTextItem *item = static_cast<MyTextItem *>(m_startViewport->childItems().at(0));
         if (item) {
             QFont font = item->font();
             font.setPixelSize(m_startViewport->rect().width() / 10);
             item->setFont(font);
         }
     }
     if (!m_endViewport->childItems().isEmpty()) {
         MyTextItem *item = static_cast<MyTextItem *>(m_endViewport->childItems().at(0));
         if (item) {
             QFont font = item->font();
             font.setPixelSize(m_endViewport->rect().width() / 10);
             item->setFont(font);
         }
     }
 }
 
 void TitleWidget::deleteAnimInfoText()
 {
     // end animation editing, remove info text
     while (!m_startViewport->childItems().isEmpty()) {
         QGraphicsItem *item = m_startViewport->childItems().at(0);
         if (m_scene) {
             m_scene->removeItem(item);
         }
     }
     while (!m_endViewport->childItems().isEmpty()) {
         QGraphicsItem *item = m_endViewport->childItems().at(0);
         if (m_scene) {
             m_scene->removeItem(item);
         }
     }
 }
 
 void TitleWidget::slotKeepAspect(bool keep)
 {
     if ((int)m_endViewport->zValue() == 1100) {
         m_endViewport->setData(0, keep ? m_frameWidth : QVariant());
         m_endViewport->setData(1, keep ? m_frameHeight : QVariant());
     } else {
         m_startViewport->setData(0, keep ? m_frameWidth : QVariant());
         m_startViewport->setData(1, keep ? m_frameHeight : QVariant());
     }
 }
 
 void TitleWidget::slotResize50()
 {
     if ((int)m_endViewport->zValue() == 1100) {
         m_endViewport->setRect(0, 0, m_frameWidth / 2, m_frameHeight / 2);
     } else {
         m_startViewport->setRect(0, 0, m_frameWidth / 2, m_frameHeight / 2);
     }
 }
 
 void TitleWidget::slotResize100()
 {
     if ((int)m_endViewport->zValue() == 1100) {
         m_endViewport->setRect(0, 0, m_frameWidth, m_frameHeight);
     } else {
         m_startViewport->setRect(0, 0, m_frameWidth, m_frameHeight);
     }
 }
 
 void TitleWidget::slotResize200()
 {
     if ((int)m_endViewport->zValue() == 1100) {
         m_endViewport->setRect(0, 0, m_frameWidth * 2, m_frameHeight * 2);
     } else {
         m_startViewport->setRect(0, 0, m_frameWidth * 2, m_frameHeight * 2);
     }
 }
 
 void TitleWidget::slotAddEffect(int /*ix*/)
 {
     QList<QGraphicsItem *> list = graphicsView->scene()->selectedItems();
     /*
         int effect = effect_list->itemData(ix).toInt();
         if (list.size() == 1) {
             if (effect == NOEFFECT)
                 effect_stack->setHidden(true);
             else {
                 effect_stack->setCurrentIndex(effect - 1);
                 effect_stack->setHidden(false);
             }
         } else // Hide the effects stack when more than one element is selected.
             effect_stack->setHidden(true);
         for (QGraphicsItem * item :  list) {
             switch (effect) {
             case NOEFFECT:
                 item->setData(100, QVariant());
                 item->setGraphicsEffect(0);
                 break;
             case TYPEWRITEREFFECT:
                 if (item->type() == TEXTITEM) {
                     QStringList effdata = QStringList() << QStringLiteral("typewriter") << QString::number(typewriter_delay->value()) + QLatin1Char(';') +
        QString::number(typewriter_start->value());
                     item->setData(100, effdata);
                 }
                 break;
                 // Do not remove the non-QGraphicsEffects.
             case BLUREFFECT:
                 item->setGraphicsEffect(new QGraphicsBlurEffect());
                 break;
             case SHADOWEFFECT:
                 item->setGraphicsEffect(new QGraphicsDropShadowEffect());
                 break;
             }
         }*/
 }
 
 qreal TitleWidget::zIndexBounds(bool maxBound, bool intersectingOnly)
 {
     qreal bound = maxBound ? -99 : 99;
     const QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (!l.isEmpty()) {
         QList<QGraphicsItem *> lItems;
         // Get items (all or intersecting only)
         if (intersectingOnly) {
             lItems = graphicsView->scene()->items(l[0]->sceneBoundingRect(), Qt::IntersectsItemShape);
         } else {
             lItems = graphicsView->scene()->items();
         }
         if (!lItems.isEmpty()) {
             int n = lItems.size();
             qreal z;
             if (maxBound) {
                 for (int i = 0; i < n; ++i) {
                     z = lItems[i]->zValue();
                     if (z > bound && !lItems[i]->isSelected()) {
                         bound = z;
                     } else if (z - 1 > bound) {
                         // To get the maximum index even if it is of an item of the current selection.
                         // Used when updating multiple items, to get all to the same level.
                         // Otherwise, the maximum would stay at -99 if the highest item is in the selection.
                         bound = z - 1;
                     }
                 }
             } else {
                 // Get minimum z index.
                 for (int i = 0; i < n; ++i) {
                     z = lItems[i]->zValue();
                     if (z < bound && !lItems[i]->isSelected() && z > -999) {
                         // There are items at the very bottom (background e.g.) with z-index < -1000.
                         bound = z;
                     } else if (z + 1 < bound && z > -999) {
                         bound = z + 1;
                     }
                 }
             }
         }
     }
     return bound;
 }
 
 void TitleWidget::slotZIndexUp()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() >= 1) {
         qreal currentZ = l[0]->zValue();
         qreal max = zIndexBounds(true, true);
         if (currentZ <= max) {
             l[0]->setZValue(currentZ + 1);
             updateDimension(l[0]);
         }
     }
 }
 
 void TitleWidget::slotZIndexTop()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     qreal max = zIndexBounds(true, false);
     // qCDebug(KDENLIVE_LOG) << "Max z-index is " << max << ".\n";
     for (auto &i : l) {
         qreal currentZ = i->zValue();
         if (currentZ <= max) {
             // qCDebug(KDENLIVE_LOG) << "Updating item " << i << ", is " << currentZ << ".\n";
             i->setZValue(max + 1);
         } else {
             // qCDebug(KDENLIVE_LOG) << "Not updating " << i << ", is " << currentZ << ".\n";
         }
     }
     // Update the z index value in the GUI
     if (!l.isEmpty()) {
         updateDimension(l[0]);
     }
 }
 
 void TitleWidget::slotZIndexDown()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     if (l.size() >= 1) {
         qreal currentZ = l[0]->zValue();
         qreal min = zIndexBounds(false, true);
         if (currentZ >= min) {
             l[0]->setZValue(currentZ - 1);
             updateDimension(l[0]);
         }
     }
 }
 
 void TitleWidget::slotZIndexBottom()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     qreal min = zIndexBounds(false, false);
     for (auto &i : l) {
         qreal currentZ = i->zValue();
         if (currentZ >= min) {
             i->setZValue(min - 1);
         }
     }
     // Update the z index value in the GUI
     if (!l.isEmpty()) {
         updateDimension(l[0]);
     }
 }
 
 void TitleWidget::slotSelectAll()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->items();
     for (auto i : l) {
         i->setSelected(true);
     }
 }
 
 void TitleWidget::selectItems(int itemType)
 {
     QList<QGraphicsItem *> l;
     if (!graphicsView->scene()->selectedItems().isEmpty()) {
         l = graphicsView->scene()->selectedItems();
         for (auto i : l) {
             if (i->type() != itemType) {
                 i->setSelected(false);
             }
         }
     } else {
         l = graphicsView->scene()->items();
         for (auto i : l) {
             if (i->type() == itemType) {
                 i->setSelected(true);
             }
         }
     }
 }
 
 void TitleWidget::slotSelectText()
 {
     selectItems(TEXTITEM);
 }
 
 void TitleWidget::slotSelectRects()
 {
     selectItems(RECTITEM);
 }
 
 void TitleWidget::slotSelectImages()
 {
     selectItems(IMAGEITEM);
 }
 
 void TitleWidget::slotSelectNone()
 {
     graphicsView->blockSignals(true);
     QList<QGraphicsItem *> l = graphicsView->scene()->items();
     for (auto i : l) {
         i->setSelected(false);
     }
     graphicsView->blockSignals(false);
     selectionChanged();
 }
 
 QString TitleWidget::getTooltipWithShortcut(const QString &tipText, QAction *button)
 {
     return tipText + QStringLiteral("  <b>") + button->shortcut().toString() + QStringLiteral("</b>");
 }
 
 void TitleWidget::prepareTools(QGraphicsItem *referenceItem)
 {
     // Let some GUI elements block signals. We may want to change their values without any sideeffects.
     // Additionally, store the previous blocking state to avoid side effects when this function is called from within another one.
     // Note: Disabling an element also blocks signals. So disabled elements don't need to be set to blocking too.
     bool blockOX = origin_x_left->signalsBlocked();
     bool blockOY = origin_y_top->signalsBlocked();
     bool blockRX = itemrotatex->signalsBlocked();
     bool blockRY = itemrotatey->signalsBlocked();
     bool blockRZ = itemrotatez->signalsBlocked();
     bool blockZoom = itemzoom->signalsBlocked();
     bool blockX = value_x->signalsBlocked();
     bool blockY = value_y->signalsBlocked();
     bool blockW = value_w->signalsBlocked();
     bool blockH = value_h->signalsBlocked();
     origin_x_left->blockSignals(true);
     origin_y_top->blockSignals(true);
     itemrotatex->blockSignals(true);
     itemrotatey->blockSignals(true);
     itemrotatez->blockSignals(true);
     itemzoom->blockSignals(true);
     value_x->blockSignals(true);
     value_y->blockSignals(true);
     value_w->blockSignals(true);
     value_h->blockSignals(true);
 
     if (referenceItem == nullptr) {
         // qCDebug(KDENLIVE_LOG) << "nullptr item.\n";
         origin_x_left->setChecked(false);
         origin_y_top->setChecked(false);
         updateTextOriginX();
         updateTextOriginY();
         enableToolbars(TITLE_SELECT);
         showToolbars(TITLE_SELECT);
 
         itemzoom->setEnabled(false);
         itemrotatex->setEnabled(false);
         itemrotatey->setEnabled(false);
         itemrotatez->setEnabled(false);
         frame_properties->setEnabled(false);
         toolbar_stack->setEnabled(false);
         /*letter_spacing->setEnabled(false);
         line_spacing->setEnabled(false);
         letter_spacing->setValue(0);
         line_spacing->setValue(0);*/
     } else {
         toolbar_stack->setEnabled(true);
         frame_properties->setEnabled(true);
         if (referenceItem != m_startViewport && referenceItem != m_endViewport) {
             itemzoom->setEnabled(true);
             itemrotatex->setEnabled(true);
             itemrotatey->setEnabled(true);
             itemrotatez->setEnabled(true);
         } else {
             itemzoom->setEnabled(false);
             itemrotatex->setEnabled(false);
             itemrotatey->setEnabled(false);
             itemrotatez->setEnabled(false);
             updateInfoText();
         }
 
         letter_spacing->setEnabled(referenceItem->type() == TEXTITEM);
         line_spacing->setEnabled(referenceItem->type() == TEXTITEM);
 
         if (referenceItem->type() == TEXTITEM) {
             showToolbars(TITLE_TEXT);
             auto *i = static_cast<MyTextItem *>(referenceItem);
             if (!i->document()->isEmpty()) {
                 // We have an existing text item selected
                 if (!i->data(100).isNull()) {
                     // Item has an effect
                     /*QStringList effdata = i->data(100).toStringList();
                     QString effectName = effdata.takeFirst();
                     if (effectName == QLatin1String("typewriter")) {
                         QStringList params = effdata.at(0).split(QLatin1Char(';'));
                         typewriter_delay->setValue(params.at(0).toInt());
                         typewriter_start->setValue(params.at(1).toInt());
                         effect_list->setCurrentIndex(effect_list->findData((int)TYPEWRITEREFFECT));
                     }*/
                 } else {
                     /*if (i->graphicsEffect()) {
                         QGraphicsBlurEffect *blur = static_cast <QGraphicsBlurEffect *>(i->graphicsEffect());
                         if (blur) {
                             effect_list->setCurrentIndex(effect_list->findData((int) BLUREFFECT));
                             int rad = (int) blur->blurRadius();
                             blur_radius->setValue(rad);
                             effect_stack->setHidden(false);
                         } else {
                             QGraphicsDropShadowEffect *shad = static_cast <QGraphicsDropShadowEffect *>(i->graphicsEffect());
                             if (shad) {
                                 effect_list->setCurrentIndex(effect_list->findData((int) SHADOWEFFECT));
                                 shadow_radius->setValue(shad->blurRadius());
                                 shadow_x->setValue(shad->xOffset());
                                 shadow_y->setValue(shad->yOffset());
                                 effect_stack->setHidden(false);
                             }
                         }
                     } else {
                         effect_list->setCurrentIndex(effect_list->findData((int) NOEFFECT));
                         effect_stack->setHidden(true);
                     }*/
                 }
                 font_size->blockSignals(true);
                 font_family->blockSignals(true);
                 font_weight_box->blockSignals(true);
                 buttonItalic->blockSignals(true);
                 buttonUnder->blockSignals(true);
                 fontColorButton->blockSignals(true);
                 buttonAlignLeft->blockSignals(true);
                 buttonAlignRight->blockSignals(true);
                 buttonAlignCenter->blockSignals(true);
 
                 QFont font = i->font();
                 font_family->setCurrentFont(font);
                 font_size->setValue(font.pixelSize());
                 m_scene->slotUpdateFontSize(font.pixelSize());
                 buttonItalic->setChecked(font.italic());
                 buttonUnder->setChecked(font.underline());
                 setFontBoxWeight(font.weight());
 
                 QTextCursor cursor(i->document());
                 cursor.select(QTextCursor::Document);
                 QColor color = cursor.charFormat().foreground().color();
                 fontColorButton->setColor(color);
 
                 if (!i->data(TitleDocument::OutlineWidth).isNull()) {
                     textOutline->blockSignals(true);
                     textOutline->setValue(i->data(TitleDocument::OutlineWidth).toDouble() * 10);
                     textOutline->blockSignals(false);
                 } else {
                     textOutline->blockSignals(true);
                     textOutline->setValue(0);
                     textOutline->blockSignals(false);
                 }
                 if (!i->data(TitleDocument::OutlineColor).isNull()) {
                     textOutlineColor->blockSignals(true);
                     QVariant variant = i->data(TitleDocument::OutlineColor);
                     color = variant.value<QColor>();
                     textOutlineColor->setColor(color);
                     textOutlineColor->blockSignals(false);
                 }
                 if (!i->data(TitleDocument::Gradient).isNull()) {
                     gradients_combo->blockSignals(true);
                     gradient_color->setChecked(true);
                     QString gradientData = i->data(TitleDocument::Gradient).toString();
                     int ix = gradients_combo->findData(gradientData);
                     if (ix == -1) {
                         // This gradient does not exist in our settings, store it
                         storeGradient(gradientData);
                         ix = gradients_combo->findData(gradientData);
                     }
                     gradients_combo->setCurrentIndex(ix);
                     gradients_combo->blockSignals(false);
                 } else {
                     plain_color->setChecked(true);
                 }
                 if (i->alignment() == Qt::AlignHCenter) {
                     buttonAlignCenter->setChecked(true);
                 } else if (i->alignment() == Qt::AlignRight) {
                     buttonAlignRight->setChecked(true);
                 } else {
                     buttonAlignLeft->setChecked(true);
                 }
 
                 QStringList sInfo = i->shadowInfo();
                 if (sInfo.count() >= 5) {
                     shadowBox->setChecked(static_cast<bool>(sInfo.at(0).toInt()));
                     shadowBox->blockSignals(true);
                     shadowColor->setColor(QColor(sInfo.at(1)));
                     blur_radius->setValue(sInfo.at(2).toInt());
                     shadowX->setValue(sInfo.at(3).toInt());
                     shadowY->setValue(sInfo.at(4).toInt());
                     shadowBox->blockSignals(false);
                 }
 
                 letter_spacing->blockSignals(true);
                 line_spacing->blockSignals(true);
                 QTextCursor cur = i->textCursor();
                 QTextBlockFormat format = cur.blockFormat();
                 letter_spacing->setValue(font.letterSpacing());
                 line_spacing->setValue(format.lineHeight());
                 letter_spacing->blockSignals(false);
                 line_spacing->blockSignals(false);
 
                 font_size->blockSignals(false);
                 font_family->blockSignals(false);
                 font_weight_box->blockSignals(false);
                 buttonItalic->blockSignals(false);
                 buttonUnder->blockSignals(false);
                 fontColorButton->blockSignals(false);
                 buttonAlignLeft->blockSignals(false);
                 buttonAlignRight->blockSignals(false);
                 buttonAlignCenter->blockSignals(false);
 
                 // mbt 1607: Select text if the text item is an unchanged template item.
                 if (i->property("isTemplate").isValid()) {
                     cur.setPosition(0, QTextCursor::MoveAnchor);
                     cur.select(QTextCursor::Document);
                     i->setTextCursor(cur);
                     // Make text editable now.
                     i->grabKeyboard();
                     i->setTextInteractionFlags(Qt::TextEditorInteraction);
                 }
             }
 
             updateAxisButtons(i);
             updateCoordinates(i);
             updateDimension(i);
             enableToolbars(TITLE_TEXT);
 
         } else if ((referenceItem)->type() == RECTITEM) {
             showToolbars(TITLE_RECTANGLE);
             settingUp = 1;
             auto *rec = static_cast<QGraphicsRectItem *>(referenceItem);
             if (rec == m_startViewport || rec == m_endViewport) {
                 enableToolbars(TITLE_SELECT);
             } else {
                 QColor fcol = rec->pen().color();
                 QColor bcol = rec->brush().color();
                 rectFColor->setColor(fcol);
                 QString gradientData = rec->data(TitleDocument::Gradient).toString();
                 if (gradientData.isEmpty()) {
                     plain_rect->setChecked(true);
                     rectBColor->setColor(bcol);
                 } else {
                     gradient_rect->setChecked(true);
                     gradients_rect_combo->blockSignals(true);
                     int ix = gradients_rect_combo->findData(gradientData);
                     if (ix == -1) {
                         storeGradient(gradientData);
                         ix = gradients_rect_combo->findData(gradientData);
                     }
                     gradients_rect_combo->setCurrentIndex(ix);
                     gradients_rect_combo->blockSignals(false);
                 }
                 settingUp = 0;
                 if (rec->pen() == Qt::NoPen) {
                     rectLineWidth->setValue(0);
                 } else {
                     rectLineWidth->setValue(rec->pen().width());
                 }
                 enableToolbars(TITLE_RECTANGLE);
             }
 
             updateAxisButtons(referenceItem);
             updateCoordinates(rec);
             updateDimension(rec);
 
         } else if (referenceItem->type() == IMAGEITEM) {
             showToolbars(TITLE_IMAGE);
 
             updateCoordinates(referenceItem);
             updateDimension(referenceItem);
 
             enableToolbars(TITLE_IMAGE);
 
         } else {
             showToolbars(TITLE_SELECT);
             enableToolbars(TITLE_SELECT);
             frame_properties->setEnabled(false);
         }
         zValue->setValue((int)referenceItem->zValue());
         if (!referenceItem->data(TitleDocument::ZoomFactor).isNull()) {
             itemzoom->setValue(referenceItem->data(TitleDocument::ZoomFactor).toInt());
         } else {
             itemzoom->setValue((int)(m_transformations.value(referenceItem).scalex * 100.0 + 0.5));
         }
         itemrotatex->setValue((int)(m_transformations.value(referenceItem).rotatex));
         itemrotatey->setValue((int)(m_transformations.value(referenceItem).rotatey));
         itemrotatez->setValue((int)(m_transformations.value(referenceItem).rotatez));
     }
 
     itemrotatex->blockSignals(blockRX);
     itemrotatey->blockSignals(blockRY);
     itemrotatez->blockSignals(blockRZ);
     itemzoom->blockSignals(blockZoom);
     origin_x_left->blockSignals(blockOX);
     origin_y_top->blockSignals(blockOY);
     value_x->blockSignals(blockX);
     value_y->blockSignals(blockY);
     value_w->blockSignals(blockW);
     value_h->blockSignals(blockH);
 }
 
 void TitleWidget::slotEditGradient()
 {
     auto *caller = qobject_cast<QToolButton *>(QObject::sender());
     if (!caller) {
         return;
     }
     QComboBox *combo = nullptr;
     if (caller == edit_gradient) {
         combo = gradients_combo;
     } else {
         combo = gradients_rect_combo;
     }
     QMap<QString, QString> gradients;
     for (int i = 0; i < combo->count(); i++) {
         gradients.insert(combo->itemText(i), combo->itemData(i).toString());
     }
     GradientWidget d(gradients, combo->currentIndex());
     if (d.exec() == QDialog::Accepted) {
         // Save current gradients
         QMap<QString, QString> gradMap = d.gradients();
         QList<QIcon> icons = d.icons();
         QMap<QString, QString>::const_iterator i = gradMap.constBegin();
         KSharedConfigPtr config = KSharedConfig::openConfig();
         KConfigGroup group(config, "TitleGradients");
         group.deleteGroup();
         combo->clear();
         gradients_rect_combo->clear();
         int ix = 0;
         while (i != gradMap.constEnd()) {
             group.writeEntry(i.key(), i.value());
             gradients_combo->addItem(icons.at(ix), i.key(), i.value());
             gradients_rect_combo->addItem(icons.at(ix), i.key(), i.value());
             ++i;
             ix++;
         }
         group.sync();
         combo->setCurrentIndex(d.selectedGradient());
     }
 }
 
 void TitleWidget::storeGradient(const QString &gradientData)
 {
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup group(config, "TitleGradients");
     QMap<QString, QString> values = group.entryMap();
     int ix = qMax(1, values.count());
     QString gradName = i18n("Gradient %1", ix);
     while (values.contains(gradName)) {
         ix++;
         gradName = i18n("Gradient %1", ix);
     }
     group.writeEntry(gradName, gradientData);
     group.sync();
     QPixmap pix(30, 30);
     pix.fill(Qt::transparent);
     QLinearGradient gr = GradientWidget::gradientFromString(gradientData, pix.width(), pix.height());
     gr.setStart(0, pix.height() / 2);
     gr.setFinalStop(pix.width(), pix.height() / 2);
     QPainter painter(&pix);
     painter.fillRect(0, 0, pix.width(), pix.height(), QBrush(gr));
     painter.end();
     QIcon icon(pix);
     gradients_combo->addItem(icon, gradName, gradientData);
     gradients_rect_combo->addItem(icon, gradName, gradientData);
 }
 
 void TitleWidget::loadGradients()
 {
     QMap<QString, QString> gradients;
     gradients_combo->blockSignals(true);
     gradients_rect_combo->blockSignals(true);
     QString grad_data = gradients_combo->currentData().toString();
     QString rect_data = gradients_rect_combo->currentData().toString();
     gradients_combo->clear();
     gradients_rect_combo->clear();
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup group(config, "TitleGradients");
     QMap<QString, QString> values = group.entryMap();
     if (values.isEmpty()) {
         // Ensure we at least always have one sample black to white gradient
         values.insert(i18n("Gradient"), QStringLiteral("#ffffffff;#ff000000;0;100;90"));
     }
     QMapIterator<QString, QString> k(values);
     while (k.hasNext()) {
         k.next();
         QPixmap pix(30, 30);
         pix.fill(Qt::transparent);
         QLinearGradient gr = GradientWidget::gradientFromString(k.value(), pix.width(), pix.height());
         gr.setStart(0, pix.height() / 2);
         gr.setFinalStop(pix.width(), pix.height() / 2);
         QPainter painter(&pix);
         painter.fillRect(0, 0, pix.width(), pix.height(), QBrush(gr));
         painter.end();
         QIcon icon(pix);
         gradients_combo->addItem(icon, k.key(), k.value());
         gradients_rect_combo->addItem(icon, k.key(), k.value());
     }
     int ix = gradients_combo->findData(grad_data);
     if (ix >= 0) {
         gradients_combo->setCurrentIndex(ix);
     }
     ix = gradients_rect_combo->findData(rect_data);
     if (ix >= 0) {
         gradients_rect_combo->setCurrentIndex(ix);
     }
     gradients_combo->blockSignals(false);
     gradients_rect_combo->blockSignals(false);
 }
 
 void TitleWidget::slotUpdateShadow()
 {
     QList<QGraphicsItem *> l = graphicsView->scene()->selectedItems();
     for (int i = 0; i < graphicsView->scene()->selectedItems().length(); ++i) {
         MyTextItem *item = nullptr;
         if (l.at(i)->type() == TEXTITEM) {
             item = static_cast<MyTextItem *>(l.at(i));
         }
         if (!item) {
             // No text item, try next one.
             continue;
         }
         item->updateShadow(shadowBox->isChecked(), blur_radius->value(), shadowX->value(), shadowY->value(), shadowColor->color());
     }
 }
 
 const QString TitleWidget::titleSuggest()
 {
     // Find top item to extract title proposal
     QList<QGraphicsItem *> list = graphicsView->scene()->items();
     int y = m_frameHeight;
     QString title;
     for (QGraphicsItem *qgItem : list) {
         if (qgItem->pos().y() < y && qgItem->type() == TEXTITEM) {
             auto *i = static_cast<MyTextItem *>(qgItem);
             QString currentTitle = i->toPlainText().simplified();
             if (currentTitle.length() > 2) {
                 title = currentTitle.length() > 12 ? currentTitle.left(12) + QStringLiteral("...") : currentTitle;
                 y = qgItem->pos().y();
             }
         }
     }
     return title;
 }
 
 void TitleWidget::showGuides(int state)
 {
     for (QGraphicsLineItem *it : m_guides) {
         it->setVisible(state == Qt::Checked);
     }
     KdenliveSettings::setTitlerShowGuides(state == Qt::Checked);
 }
 
 void TitleWidget::updateGuides(int)
 {
     KdenliveSettings::setTitlerHGuides(hguides->value());
     KdenliveSettings::setTitlerVGuides(vguides->value());
     if (!m_guides.isEmpty()) {
         qDeleteAll(m_guides);
         m_guides.clear();
     }
     QPen framepen;
     QColor gColor(KdenliveSettings::titleGuideColor());
     framepen.setColor(gColor);
 
     // Guides
     // Horizontal guides
     int max = hguides->value();
     bool guideVisible = show_guides->checkState() == Qt::Checked;
     for (int i = 0; i < max; i++) {
         auto *line1 = new QGraphicsLineItem(0, (i + 1) * m_frameHeight / (max + 1), m_frameWidth, (i + 1) * m_frameHeight / (max + 1), m_frameBorder);
         line1->setPen(framepen);
         line1->setFlags({});
         line1->setData(-1, -1);
         line1->setVisible(guideVisible);
         m_guides << line1;
     }
     max = vguides->value();
     for (int i = 0; i < max; i++) {
         auto *line1 = new QGraphicsLineItem((i + 1) * m_frameWidth / (max + 1), 0, (i + 1) * m_frameWidth / (max + 1), m_frameHeight, m_frameBorder);
         line1->setPen(framepen);
         line1->setFlags({});
         line1->setData(-1, -1);
         line1->setVisible(guideVisible);
         m_guides << line1;
     }
 
     gColor.setAlpha(160);
     framepen.setColor(gColor);
 
     auto *line6 = new QGraphicsLineItem(0, 0, m_frameWidth, m_frameHeight, m_frameBorder);
     line6->setPen(framepen);
     line6->setFlags({});
     line6->setData(-1, -1);
     line6->setVisible(guideVisible);
     m_guides << line6;
 
     auto *line7 = new QGraphicsLineItem(m_frameWidth, 0, 0, m_frameHeight, m_frameBorder);
     line7->setPen(framepen);
     line7->setFlags({});
     line7->setData(-1, -1);
     line7->setVisible(guideVisible);
     m_guides << line7;
 }
 
 void TitleWidget::guideColorChanged(const QColor &col)
 {
     KdenliveSettings::setTitleGuideColor(col);
     QColor guideCol(col);
     for (QGraphicsLineItem *it : m_guides) {
         int alpha = it->pen().color().alpha();
         guideCol.setAlpha(alpha);
         QPen framePen(guideCol);
         it->setPen(framePen);
     }
 }