diff --git a/src/core.cpp b/src/core.cpp
index 4cdbe47a7..21981e64b 100644
--- a/src/core.cpp
+++ b/src/core.cpp
@@ -1,867 +1,867 @@
 /*
 Copyright (C) 2014  Till Theato <root@ttill.de>
 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 3 of the License, or
 (at your option) any later version.
 */
 
 #include "core.h"
 #include "bin/bin.h"
 #include "bin/projectitemmodel.h"
 #include "capture/mediacapture.h"
 #include "doc/docundostack.hpp"
 #include "doc/kdenlivedoc.h"
 #include "jobs/jobmanager.h"
 #include "kdenlive_debug.h"
 #include "kdenlivesettings.h"
 #include "library/librarywidget.h"
 #include "audiomixer/mixermanager.hpp"
 #include "mainwindow.h"
 #include "mltconnection.h"
 #include "mltcontroller/clipcontroller.h"
 #include "monitor/monitormanager.h"
 #include "profiles/profilemodel.hpp"
 #include "profiles/profilerepository.hpp"
 #include "project/projectmanager.h"
 #include "timeline2/model/timelineitemmodel.hpp"
 #include "timeline2/view/timelinecontroller.h"
 #include "timeline2/view/timelinewidget.h"
 
 #include <mlt++/MltRepository.h>
 
 #include <KMessageBox>
 #include <QCoreApplication>
 #include <QInputDialog>
 #include <QDir>
 
 #include <locale>
 #ifdef Q_OS_MAC
 #include <xlocale.h>
 #endif
 
 std::unique_ptr<Core> Core::m_self;
 Core::Core()
     : m_thumbProfile(nullptr)
     , m_capture(new MediaCapture(this))
 {
 }
 
 void Core::prepareShutdown()
 {
     m_guiConstructed = false;
     QThreadPool::globalInstance()->clear();
 }
 
 Core::~Core()
 {
     qDebug() << "deleting core";
     if (m_monitorManager) {
         delete m_monitorManager;
     }
     // delete m_binWidget;
     if (m_projectManager) {
         delete m_projectManager;
     }
     ClipController::mediaUnavailable.reset();
 }
 
 void Core::build(bool isAppImage, const QString &MltPath)
 {
     if (m_self) {
         return;
     }
     m_self.reset(new Core());
     m_self->initLocale();
 
     qRegisterMetaType<audioShortVector>("audioShortVector");
     qRegisterMetaType<QVector<double>>("QVector<double>");
     qRegisterMetaType<MessageType>("MessageType");
     qRegisterMetaType<stringMap>("stringMap");
     qRegisterMetaType<audioByteArray>("audioByteArray");
     qRegisterMetaType<QList<ItemInfo>>("QList<ItemInfo>");
     qRegisterMetaType<std::shared_ptr<Mlt::Producer>>("std::shared_ptr<Mlt::Producer>");
     qRegisterMetaType<QVector<int>>();
     qRegisterMetaType<QDomElement>("QDomElement");
     qRegisterMetaType<requestClipInfo>("requestClipInfo");
     
     if (isAppImage) {
         QString appPath = qApp->applicationDirPath();
         KdenliveSettings::setFfmpegpath(QDir::cleanPath(appPath + QStringLiteral("/ffmpeg")));
         KdenliveSettings::setFfplaypath(QDir::cleanPath(appPath + QStringLiteral("/ffplay")));
         KdenliveSettings::setFfprobepath(QDir::cleanPath(appPath + QStringLiteral("/ffprobe")));
         KdenliveSettings::setRendererpath(QDir::cleanPath(appPath + QStringLiteral("/melt")));
         MltConnection::construct(QDir::cleanPath(appPath + QStringLiteral("/../share/mlt/profiles")));
     } else {
         // Open connection with Mlt
         MltConnection::construct(MltPath);
     }
 
     // load the profile from disk
     ProfileRepository::get()->refresh();
     // load default profile
     m_self->m_profile = KdenliveSettings::default_profile();
     if (m_self->m_profile.isEmpty()) {
         m_self->m_profile = ProjectManager::getDefaultProjectFormat();
         KdenliveSettings::setDefault_profile(m_self->m_profile);
     }
 
     // Init producer shown for unavailable media
     // TODO make it a more proper image, it currently causes a crash on exit
     ClipController::mediaUnavailable = std::make_shared<Mlt::Producer>(ProfileRepository::get()->getProfile(m_self->m_profile)->profile(), "color:blue");
     ClipController::mediaUnavailable->set("length", 99999999);
 
     m_self->m_projectItemModel = ProjectItemModel::construct();
     // Job manager must be created before bin to correctly connect
     m_self->m_jobManager.reset(new JobManager(m_self.get()));
 }
 
-void Core::initGUI(const QUrl &Url)
+void Core::initGUI(const QUrl &Url, const QString &clipsToLoad)
 {
     m_guiConstructed = true;
     m_profile = KdenliveSettings::default_profile();
     m_currentProfile = m_profile;
     profileChanged();
     m_mainWindow = new MainWindow();
     connect(this, &Core::showConfigDialog, m_mainWindow, &MainWindow::slotPreferences);
 
     // load default profile and ask user to select one if not found.
     if (m_profile.isEmpty()) {
         m_profile = ProjectManager::getDefaultProjectFormat();
         profileChanged();
         KdenliveSettings::setDefault_profile(m_profile);
     }
     updatePreviewProfile();
 
     if (!ProfileRepository::get()->profileExists(m_profile)) {
         KMessageBox::sorry(m_mainWindow, i18n("The default profile of Kdenlive is not set or invalid, press OK to set it to a correct value."));
 
         // TODO this simple widget should be improved and probably use profileWidget
         // we get the list of profiles
         QVector<QPair<QString, QString>> all_profiles = ProfileRepository::get()->getAllProfiles();
         QStringList all_descriptions;
         for (const auto &profile : all_profiles) {
             all_descriptions << profile.first;
         }
 
         // ask the user
         bool ok;
         QString item = QInputDialog::getItem(m_mainWindow, i18n("Select Default Profile"), i18n("Profile:"), all_descriptions, 0, false, &ok);
         if (ok) {
             ok = false;
             for (const auto &profile : all_profiles) {
                 if (profile.first == item) {
                     m_profile = profile.second;
                     ok = true;
                 }
             }
         }
         if (!ok) {
             KMessageBox::error(
                 m_mainWindow,
                 i18n("The given profile is invalid. We default to the profile \"dv_pal\", but you can change this from Kdenlive's settings panel"));
             m_profile = QStringLiteral("dv_pal");
         }
         KdenliveSettings::setDefault_profile(m_profile);
         profileChanged();
     }
 
     m_projectManager = new ProjectManager(this);
     m_binWidget = new Bin(m_projectItemModel, m_mainWindow);
     m_library = new LibraryWidget(m_projectManager, m_mainWindow);
     m_mixerWidget = new MixerManager(m_mainWindow);
     connect(m_library, SIGNAL(addProjectClips(QList<QUrl>)), m_binWidget, SLOT(droppedUrls(QList<QUrl>)));
     connect(this, &Core::updateLibraryPath, m_library, &LibraryWidget::slotUpdateLibraryPath);
     connect(m_capture.get(), &MediaCapture::recordStateChanged, m_mixerWidget, &MixerManager::recordStateChanged);
     m_monitorManager = new MonitorManager(this);
     connect(m_monitorManager, &MonitorManager::cleanMixer, m_mixerWidget, &MixerManager::clearMixers);
     // Producer queue, creating MLT::Producers on request
     /*
     m_producerQueue = new ProducerQueue(m_binController);
     connect(m_producerQueue, &ProducerQueue::gotFileProperties, m_binWidget, &Bin::slotProducerReady);
     connect(m_producerQueue, &ProducerQueue::replyGetImage, m_binWidget, &Bin::slotThumbnailReady);
     connect(m_producerQueue, &ProducerQueue::requestProxy,
             [this](const QString &id){ m_binWidget->startJob(id, AbstractClipJob::PROXYJOB);});
     connect(m_producerQueue, &ProducerQueue::removeInvalidClip, m_binWidget, &Bin::slotRemoveInvalidClip, Qt::DirectConnection);
     connect(m_producerQueue, SIGNAL(addClip(QString, QMap<QString, QString>)), m_binWidget, SLOT(slotAddUrl(QString, QMap<QString, QString>)));
     connect(m_binController.get(), SIGNAL(createThumb(QDomElement, QString, int)), m_producerQueue, SLOT(getFileProperties(QDomElement, QString, int)));
     connect(m_binWidget, &Bin::producerReady, m_producerQueue, &ProducerQueue::slotProcessingDone, Qt::DirectConnection);
     // TODO
     connect(m_producerQueue, SIGNAL(removeInvalidProxy(QString,bool)), m_binWidget, SLOT(slotRemoveInvalidProxy(QString,bool)));*/
 
     m_mainWindow->init();
-    projectManager()->init(Url, QString());
+    projectManager()->init(Url, clipsToLoad);
     if (qApp->isSessionRestored()) {
         // NOTE: we are restoring only one window, because Kdenlive only uses one MainWindow
         m_mainWindow->restore(1, false);
     }
     QMetaObject::invokeMethod(pCore->projectManager(), "slotLoadOnOpen", Qt::QueuedConnection);
     m_mainWindow->show();
     QThreadPool::globalInstance()->setMaxThreadCount(qMin(4, QThreadPool::globalInstance()->maxThreadCount()));
 }
 
 void Core::buildLumaThumbs(const QStringList &values)
 {
     for (auto &entry : values) {
         if (MainWindow::m_lumacache.contains(entry)) {
             continue;
         }
         QImage pix(entry);
         if (!pix.isNull()) {
             MainWindow::m_lumacache.insert(entry, pix.scaled(50, 30, Qt::KeepAspectRatio, Qt::SmoothTransformation));
         }
     }
 }
 
 std::unique_ptr<Core> &Core::self()
 {
     if (!m_self) {
         qDebug() << "Error : Core has not been created";
     }
     return m_self;
 }
 
 MainWindow *Core::window()
 {
     return m_mainWindow;
 }
 
 ProjectManager *Core::projectManager()
 {
     return m_projectManager;
 }
 
 MonitorManager *Core::monitorManager()
 {
     return m_monitorManager;
 }
 
 Monitor *Core::getMonitor(int id)
 {
     if (id == Kdenlive::ClipMonitor) {
         return m_monitorManager->clipMonitor();
     }
     return m_monitorManager->projectMonitor();
 }
 
 Bin *Core::bin()
 {
     return m_binWidget;
 }
 
 void Core::selectBinClip(const QString &clipId, int frame, const QPoint &zone)
 {
     m_binWidget->selectClipById(clipId, frame, zone);
 }
 
 std::shared_ptr<JobManager> Core::jobManager()
 {
     return m_jobManager;
 }
 
 LibraryWidget *Core::library()
 {
     return m_library;
 }
 
 MixerManager *Core::mixer()
 {
     return m_mixerWidget;
 }
 
 void Core::initLocale()
 {
     QLocale systemLocale = QLocale();
 #ifndef Q_OS_MAC
     setlocale(LC_NUMERIC, nullptr);
 #else
     setlocale(LC_NUMERIC_MASK, nullptr);
 #endif
 
 // localeconv()->decimal_point does not give reliable results on Windows
 #ifndef Q_OS_WIN
     char *separator = localeconv()->decimal_point;
     if (QString::fromUtf8(separator) != QChar(systemLocale.decimalPoint())) {
         // qCDebug(KDENLIVE_LOG)<<"------\n!!! system locale is not similar to Qt's locale... be prepared for bugs!!!\n------";
         // HACK: There is a locale conflict, so set locale to C
         // Make sure to override exported values or it won't work
         qputenv("LANG", "C");
 #ifndef Q_OS_MAC
         setlocale(LC_NUMERIC, "C");
 #else
         setlocale(LC_NUMERIC_MASK, "C");
 #endif
         systemLocale = QLocale::c();
     }
 #endif
 
     systemLocale.setNumberOptions(QLocale::OmitGroupSeparator);
     QLocale::setDefault(systemLocale);
 }
 
 std::unique_ptr<Mlt::Repository> &Core::getMltRepository()
 {
     return MltConnection::self()->getMltRepository();
 }
 
 std::unique_ptr<ProfileModel> &Core::getCurrentProfile() const
 {
     return ProfileRepository::get()->getProfile(m_currentProfile);
 }
 
 Mlt::Profile *Core::getProjectProfile()
 {
     if (!m_previewProfile) {
         m_previewProfile = std::make_unique<Mlt::Profile>(m_currentProfile.toStdString().c_str());
         updatePreviewProfile();
     }
     return m_previewProfile.get();
 }
 
 const QString &Core::getCurrentProfilePath() const
 {
     return m_currentProfile;
 }
 
 bool Core::setCurrentProfile(const QString &profilePath)
 {
     if (m_currentProfile == profilePath) {
         // no change required
         return true;
     }
     if (ProfileRepository::get()->profileExists(profilePath)) {
         m_currentProfile = profilePath;
         updatePreviewProfile();
         m_thumbProfile.reset();
         // inform render widget
         profileChanged();
         m_mainWindow->updateRenderWidgetProfile();
         if (m_guiConstructed && m_mainWindow->getCurrentTimeline()->controller()->getModel()) {
             m_mainWindow->getCurrentTimeline()->controller()->getModel()->updateProfile(getProjectProfile());
             checkProfileValidity();
         }
         return true;
     }
     return false;
 }
 
 void Core::updatePreviewProfile()
 {
     int newWidth = getCurrentProfile()->width() / KdenliveSettings::previewScaling();
     int newHeight = getCurrentProfile()->height() / KdenliveSettings::previewScaling();
     if (newWidth % 8 > 0) {
         newWidth += 8 - newWidth % 8;
     }
     newHeight += newHeight % 2;
     m_previewProfile->set_colorspace(getCurrentProfile()->colorspace());
     m_previewProfile->set_frame_rate(getCurrentProfile()->frame_rate_num(), getCurrentProfile()->frame_rate_den());
     m_previewProfile->set_width(newWidth);
     m_previewProfile->set_height(newHeight);
     m_previewProfile->set_progressive(getCurrentProfile()->progressive());
     m_previewProfile->set_sample_aspect(getCurrentProfile()->sample_aspect_num(), getCurrentProfile()->sample_aspect_den());
     m_previewProfile->set_display_aspect(getCurrentProfile()->display_aspect_num(), getCurrentProfile()->display_aspect_den());
     m_previewProfile->set_explicit(true);
 }
 
 void Core::checkProfileValidity()
 {
     int offset = (getCurrentProfile()->profile().width() % 8) + (getCurrentProfile()->profile().height() % 2);
     if (offset > 0) {
         // Profile is broken, warn user
         if (m_binWidget) {
             m_binWidget->displayBinMessage(i18n("Your project profile is invalid, rendering might fail."), KMessageWidget::Warning);
         }
     }
 }
 
 double Core::getCurrentSar() const
 {
     return getCurrentProfile()->sar();
 }
 
 double Core::getCurrentDar() const
 {
     return getCurrentProfile()->dar();
 }
 
 double Core::getCurrentFps() const
 {
     return getCurrentProfile()->fps();
 }
 
 QSize Core::getCurrentFrameDisplaySize() const
 {
     return {(int)(getCurrentProfile()->height() * getCurrentDar() + 0.5), getCurrentProfile()->height()};
 }
 
 QSize Core::getCurrentFrameSize() const
 {
     return {getCurrentProfile()->width(), getCurrentProfile()->height()};
 }
 
 void Core::requestMonitorRefresh()
 {
     if (!m_guiConstructed) return;
     m_monitorManager->refreshProjectMonitor();
 }
 
 void Core::refreshProjectRange(QSize range)
 {
     if (!m_guiConstructed) return;
     m_monitorManager->refreshProjectRange(range);
 }
 
 int Core::getItemPosition(const ObjectId &id)
 {
     if (!m_guiConstructed) return 0;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipPosition(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isComposition(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getCompositionPosition(id.second);
         }
         break;
     case ObjectType::BinClip:
     case ObjectType::TimelineTrack:
     case ObjectType::Master:
         return 0;
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 int Core::getItemIn(const ObjectId &id)
 {
     if (!m_guiConstructed || !m_mainWindow->getCurrentTimeline() || !m_mainWindow->getCurrentTimeline()->controller()->getModel()) {
         qDebug() << "/ / // QUERYING ITEM IN BUT GUI NOT BUILD!!";
         return 0;
     }
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipIn(id.second);
         } else {
             qDebug()<<"// ERROR QUERYING NON CLIP PROPERTIES\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!";
         }
         break;
     case ObjectType::TimelineComposition:
     case ObjectType::BinClip:
     case ObjectType::TimelineTrack:
     case ObjectType::Master:
         return 0;
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 PlaylistState::ClipState Core::getItemState(const ObjectId &id)
 {
     if (!m_guiConstructed) return PlaylistState::Disabled;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipState(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         return PlaylistState::VideoOnly;
         break;
     case ObjectType::BinClip:
         return m_binWidget->getClipState(id.second);
         break;
     case ObjectType::TimelineTrack:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->isAudioTrack(id.second) ? PlaylistState::AudioOnly : PlaylistState::VideoOnly;
     case ObjectType::Master:
         return PlaylistState::Disabled;
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
         break;
     }
     return PlaylistState::Disabled;
 }
 
 int Core::getItemDuration(const ObjectId &id)
 {
     if (!m_guiConstructed) return 0;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipPlaytime(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isComposition(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getCompositionPlaytime(id.second);
         }
         break;
     case ObjectType::BinClip:
         return (int)m_binWidget->getClipDuration(id.second);
         break;
     case ObjectType::TimelineTrack:
     case ObjectType::Master:
         return m_mainWindow->getCurrentTimeline()->controller()->duration();
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 int Core::getItemTrack(const ObjectId &id)
 {
     if (!m_guiConstructed) return 0;
     switch (id.first) {
     case ObjectType::TimelineClip:
     case ObjectType::TimelineComposition:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getItemTrackId(id.second);
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 void Core::refreshProjectItem(const ObjectId &id)
 {
     if (!m_guiConstructed || m_mainWindow->getCurrentTimeline()->loading) return;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             m_mainWindow->getCurrentTimeline()->controller()->refreshItem(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isComposition(id.second)) {
             m_mainWindow->getCurrentTimeline()->controller()->refreshItem(id.second);
         }
         break;
     case ObjectType::TimelineTrack:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isTrack(id.second)) {
             requestMonitorRefresh();
         }
         break;
     case ObjectType::BinClip:
         m_monitorManager->activateMonitor(Kdenlive::ClipMonitor);
         m_monitorManager->refreshClipMonitor();
         if (m_monitorManager->projectMonitorVisible() && m_mainWindow->getCurrentTimeline()->controller()->refreshIfVisible(id.second)) {
             m_monitorManager->refreshTimer.start();
         }
         break;
     case ObjectType::Master:
         requestMonitorRefresh();
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
 }
 
 bool Core::hasTimelinePreview() const
 {
     if (!m_guiConstructed) {
         return false;
     }
     return m_mainWindow->getCurrentTimeline()->controller()->renderedChunks().size() > 0;
 }
 
 KdenliveDoc *Core::currentDoc()
 {
     return m_projectManager->current();
 }
 
 int Core::projectDuration() const
 {
     if (!m_guiConstructed) {
         return 0;
     }
     return m_mainWindow->getCurrentTimeline()->controller()->duration();
 }
 
 void Core::profileChanged()
 {
     GenTime::setFps(getCurrentFps());
 }
 
 void Core::pushUndo(const Fun &undo, const Fun &redo, const QString &text)
 {
     undoStack()->push(new FunctionalUndoCommand(undo, redo, text));
 }
 
 void Core::pushUndo(QUndoCommand *command)
 {
     undoStack()->push(command);
 }
 
 void Core::displayMessage(const QString &message, MessageType type, int timeout)
 {
     if (m_mainWindow) {
         if (type == ProcessingJobMessage || type == OperationCompletedMessage) {
             m_mainWindow->displayProgressMessage(message, type, timeout);
         } else {
             m_mainWindow->displayMessage(message, type, timeout);
         }
     } else {
         qDebug() << message;
     }
 }
 
 void Core::displayBinMessage(const QString &text, int type, const QList<QAction *> &actions)
 {
     m_binWidget->doDisplayMessage(text, (KMessageWidget::MessageType)type, actions);
 }
 
 void Core::displayBinLogMessage(const QString &text, int type, const QString &logInfo)
 {
     m_binWidget->doDisplayMessage(text, (KMessageWidget::MessageType)type, logInfo);
 }
 
 void Core::clearAssetPanel(int itemId)
 {
     if (m_guiConstructed) m_mainWindow->clearAssetPanel(itemId);
 }
 
 std::shared_ptr<EffectStackModel> Core::getItemEffectStack(int itemType, int itemId)
 {
     if (!m_guiConstructed) return nullptr;
     switch (itemType) {
     case (int)ObjectType::TimelineClip:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipEffectStack(itemId);
     case (int)ObjectType::TimelineTrack:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getTrackEffectStackModel(itemId);
         break;
     case (int)ObjectType::BinClip:
         return m_binWidget->getClipEffectStack(itemId);
     case (int)ObjectType::Master:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getMasterEffectStackModel();
     default:
         return nullptr;
     }
 }
 
 std::shared_ptr<DocUndoStack> Core::undoStack()
 {
     return projectManager()->undoStack();
 }
 
 QMap<int, QString> Core::getTrackNames(bool videoOnly)
 {
     if (!m_guiConstructed) return QMap<int, QString>();
     return m_mainWindow->getCurrentTimeline()->controller()->getTrackNames(videoOnly);
 }
 
 QPair<int, int> Core::getCompositionATrack(int cid) const
 {
     if (!m_guiConstructed) return {};
     return m_mainWindow->getCurrentTimeline()->controller()->getCompositionATrack(cid);
 }
 
 bool Core::compositionAutoTrack(int cid) const
 {
     return m_mainWindow->getCurrentTimeline()->controller()->compositionAutoTrack(cid);
 }
 
 void Core::setCompositionATrack(int cid, int aTrack)
 {
     if (!m_guiConstructed) return;
     m_mainWindow->getCurrentTimeline()->controller()->setCompositionATrack(cid, aTrack);
 }
 
 std::shared_ptr<ProjectItemModel> Core::projectItemModel()
 {
     return m_projectItemModel;
 }
 
 void Core::invalidateRange(QSize range)
 {
     if (!m_mainWindow || m_mainWindow->getCurrentTimeline()->loading) return;
     m_mainWindow->getCurrentTimeline()->controller()->invalidateZone(range.width(), range.height());
 }
 
 void Core::invalidateItem(ObjectId itemId)
 {
     if (!m_mainWindow || !m_mainWindow->getCurrentTimeline() || m_mainWindow->getCurrentTimeline()->loading) return;
     switch (itemId.first) {
     case ObjectType::TimelineClip:
     case ObjectType::TimelineComposition:
         m_mainWindow->getCurrentTimeline()->controller()->invalidateItem(itemId.second);
         break;
     case ObjectType::TimelineTrack:
         m_mainWindow->getCurrentTimeline()->controller()->invalidateTrack(itemId.second);
         break;
     case ObjectType::BinClip:
         m_binWidget->invalidateClip(QString::number(itemId.second));
         break;
     case ObjectType::Master:
         m_mainWindow->getCurrentTimeline()->controller()->invalidateZone(0, -1);
         break;
     default:
         // compositions should not have effects
         break;
     }
 }
 
 double Core::getClipSpeed(int id) const
 {
     return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipSpeed(id);
 }
 
 void Core::updateItemKeyframes(ObjectId id)
 {
     if (id.first == ObjectType::TimelineClip && m_mainWindow) {
         m_mainWindow->getCurrentTimeline()->controller()->updateClip(id.second, {TimelineModel::KeyframesRole});
     }
 }
 
 void Core::updateItemModel(ObjectId id, const QString &service)
 {
     if (m_mainWindow && id.first == ObjectType::TimelineClip && !m_mainWindow->getCurrentTimeline()->loading && service.startsWith(QLatin1String("fade"))) {
         bool startFade = service == QLatin1String("fadein") || service == QLatin1String("fade_from_black");
         m_mainWindow->getCurrentTimeline()->controller()->updateClip(id.second, {startFade ? TimelineModel::FadeInRole : TimelineModel::FadeOutRole});
     }
 }
 
 void Core::showClipKeyframes(ObjectId id, bool enable)
 {
     if (id.first == ObjectType::TimelineClip) {
         m_mainWindow->getCurrentTimeline()->controller()->showClipKeyframes(id.second, enable);
     } else if (id.first == ObjectType::TimelineComposition) {
         m_mainWindow->getCurrentTimeline()->controller()->showCompositionKeyframes(id.second, enable);
     }
 }
 
 Mlt::Profile *Core::thumbProfile()
 {
     QMutexLocker lck(&m_thumbProfileMutex);
     if (!m_thumbProfile) {
         m_thumbProfile = std::make_unique<Mlt::Profile>(m_currentProfile.toStdString().c_str());
         m_thumbProfile->set_height(144);
         int width = 144 * m_thumbProfile->dar() + 0.5;
         if (width % 8 > 0) {
             width += 8 - width % 8;
         }
         m_thumbProfile->set_width(width);
     }
     return m_thumbProfile.get();
 }
 
 int Core::getTimelinePosition() const
 {
     if (m_guiConstructed) {
         return m_monitorManager->projectMonitor()->position();
     }
     return 0;
 }
 
 void Core::triggerAction(const QString &name)
 {
     QAction *action = m_mainWindow->actionCollection()->action(name);
     if (action) {
         action->trigger();
     }
 }
 
 void Core::clean()
 {
     m_self.reset();
 }
 
 void Core::startMediaCapture(int tid, bool checkAudio, bool checkVideo)
 {
     if (checkAudio && checkVideo) {
         m_capture->recordVideo(tid, true);
     } else if (checkAudio) {
         m_capture->recordAudio(tid, true);
     }
     m_mediaCaptureFile = m_capture->getCaptureOutputLocation();
 }
 
 void Core::stopMediaCapture(int tid, bool checkAudio, bool checkVideo)
 {
     if (checkAudio && checkVideo) {
         m_capture->recordVideo(tid, false);
     } else if (checkAudio) {
         m_capture->recordAudio(tid, false);
     }
 }
 
 QStringList Core::getAudioCaptureDevices()
 {
     return m_capture->getAudioCaptureDevices();
 }
 
 int Core::getMediaCaptureState()
 {
     return m_capture->getState();
 }
 
 bool Core::isMediaCapturing()
 {
     return m_capture->isRecording();
 }
 
 MediaCapture *Core::getAudioDevice()
 {
     return m_capture.get();
 }
 
 QString Core::getProjectFolderName()
 {
     if (currentDoc()) {
         return currentDoc()->projectDataFolder() + QDir::separator();
     }
     return QString();
 }
 
 QString Core::getTimelineClipBinId(int cid)
 {
     if (!m_guiConstructed) {
         return QString();
     }
     if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(cid)) {
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipBinId(cid);
     }
     return QString();
 }
 
 int Core::getDurationFromString(const QString &time)
 {
     if (!m_guiConstructed) {
         return 0;
     }
     const QString duration = currentDoc()->timecode().reformatSeparators(time);
     return currentDoc()->timecode().getFrameCount(duration);
 }
 
 void Core::processInvalidFilter(const QString service, const QString id, const QString message)
 {
     if (m_guiConstructed) m_mainWindow->assetPanelWarning(service, id, message);
 }
 
 void Core::updateProjectTags(QMap <QString, QString> tags)
 {
     // Clear previous tags
     for (int i = 1 ; i< 20; i++) {
         QString current = currentDoc()->getDocumentProperty(QString("tag%1").arg(i));
         if (current.isEmpty()) {
             break;
         } else {
             currentDoc()->setDocumentProperty(QString("tag%1").arg(i), QString());
         }
     }
     QMapIterator<QString, QString> j(tags);
     int i = 1;
     while (j.hasNext()) {
         j.next();
         currentDoc()->setDocumentProperty(QString("tag%1").arg(i), QString("%1:%2").arg(j.key()).arg(j.value()));
         i++;
     }
 }
diff --git a/src/core.h b/src/core.h
index 898eece23..362d9338a 100644
--- a/src/core.h
+++ b/src/core.h
@@ -1,257 +1,257 @@
 /*
 Copyright (C) 2014  Till Theato <root@ttill.de>
 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 3 of the License, or
 (at your option) any later version.
 */
 
 #ifndef CORE_H
 #define CORE_H
 
 #include "definitions.h"
 #include "kdenlivecore_export.h"
 #include "undohelper.hpp"
 #include <QMutex>
 #include <QObject>
 #include <QUrl>
 #include <memory>
 #include <QPoint>
 class Bin;
 class DocUndoStack;
 class EffectStackModel;
 class JobManager;
 class KdenliveDoc;
 class LibraryWidget;
 class MainWindow;
 class MediaCapture;
 class MixerManager;
 class Monitor;
 class MonitorManager;
 class ProfileModel;
 class ProjectItemModel;
 class ProjectManager;
 
 namespace Mlt {
     class Repository;
     class Profile;
 } // namespace Mlt
 
 #define EXIT_RESTART (42)
 #define EXIT_CLEAN_RESTART (43)
 #define pCore Core::self()
 
 /**
  * @class Core
  * @brief Singleton that provides access to the different parts of Kdenlive
  *
  * Needs to be initialize before any widgets are created in MainWindow.
  * Plugins should be loaded after the widget setup.
  */
 
 class /*KDENLIVECORE_EXPORT*/ Core : public QObject
 {
     Q_OBJECT
 
 public:
     Core(const Core &) = delete;
     Core &operator=(const Core &) = delete;
     Core(Core &&) = delete;
     Core &operator=(Core &&) = delete;
 
     ~Core() override;
 
     /**
      * @brief Setup the basics of the application, in particular the connection
      * with Mlt
      * @param isAppImage do we expect an AppImage (if yes, we use App path to deduce 
      * other binaries paths (melt, ffmpeg, etc)
      * @param MltPath (optional) path to MLT environment
      */
     static void build(bool isAppImage, const QString &MltPath = QString());
 
     /**
      * @brief Init the GUI part of the app and show the main window
      * @param Url (optional) file to open
      * If Url is present, it will be opened, otherwise, if openlastproject is
      * set, latest project will be opened. If no file is open after trying this,
      * a default new file will be created. */
-    void initGUI(const QUrl &Url);
+    void initGUI(const QUrl &Url, const QString &clipsToLoad = QString());
 
     /** @brief Returns a pointer to the singleton object. */
     static std::unique_ptr<Core> &self();
 
     /** @brief Delete the global core instance */
     static void clean();
 
     /** @brief Returns a pointer to the main window. */
     MainWindow *window();
 
     /** @brief Returns a pointer to the project manager. */
     ProjectManager *projectManager();
     /** @brief Returns a pointer to the current project. */
     KdenliveDoc *currentDoc();
     /** @brief Returns a pointer to the monitor manager. */
     MonitorManager *monitorManager();
     /** @brief Returns a pointer to the view of the project bin. */
     Bin *bin();
     /** @brief Select a clip in the Bin from its id. */
     void selectBinClip(const QString &id, int frame = -1, const QPoint &zone = QPoint());
     /** @brief Returns a pointer to the model of the project bin. */
     std::shared_ptr<ProjectItemModel> projectItemModel();
     /** @brief Returns a pointer to the job manager. Please do not store it. */
     std::shared_ptr<JobManager> jobManager();
     /** @brief Returns a pointer to the library. */
     LibraryWidget *library();
     /** @brief Returns a pointer to the audio mixer. */
     MixerManager *mixer();
 
     /** @brief Returns a pointer to MLT's repository */
     std::unique_ptr<Mlt::Repository> &getMltRepository();
 
     /** @brief Returns a pointer to the current profile */
     std::unique_ptr<ProfileModel> &getCurrentProfile() const;
     const QString &getCurrentProfilePath() const;
 
     /** @brief Define the active profile
      *  @returns true if profile exists, false if not found
      */
     bool setCurrentProfile(const QString &profilePath);
     /** @brief Returns Sample Aspect Ratio of current profile */
     double getCurrentSar() const;
     /** @brief Returns Display Aspect Ratio of current profile */
     double getCurrentDar() const;
 
     /** @brief Returns frame rate of current profile */
     double getCurrentFps() const;
 
     /** @brief Returns the frame size (width x height) of current profile */
     QSize getCurrentFrameSize() const;
     /** @brief Returns the frame display size (width x height) of current profile */
     QSize getCurrentFrameDisplaySize() const;
     /** @brief Request project monitor refresh */
     void requestMonitorRefresh();
     /** @brief Request project monitor refresh if current position is inside range*/
     void refreshProjectRange(QSize range);
     /** @brief Request project monitor refresh if referenced item is under cursor */
     void refreshProjectItem(const ObjectId &id);
     /** @brief Returns a reference to a monitor (clip or project monitor) */
     Monitor *getMonitor(int id);
 
     /** @brief This function must be called whenever the profile used changes */
     void profileChanged();
 
     /** @brief Create and push and undo object based on the corresponding functions
         Note that if you class permits and requires it, you should use the macro PUSH_UNDO instead*/
     void pushUndo(const Fun &undo, const Fun &redo, const QString &text);
     void pushUndo(QUndoCommand *command);
     /** @brief display a user info/warning message in statusbar */
     void displayMessage(const QString &message, MessageType type, int timeout = -1);
     /** @brief Clear asset view if itemId is displayed. */
     void clearAssetPanel(int itemId);
     /** @brief Returns the effectstack of a given bin clip. */
     std::shared_ptr<EffectStackModel> getItemEffectStack(int itemType, int itemId);
     int getItemPosition(const ObjectId &id);
     int getItemIn(const ObjectId &id);
     int getItemTrack(const ObjectId &id);
     int getItemDuration(const ObjectId &id);
     /** @brief Returns the capabilities of a clip: AudioOnly, VideoOnly or Disabled if both are allowed */
     PlaylistState::ClipState getItemState(const ObjectId &id);
     /** @brief Get a list of video track names with indexes */
     QMap<int, QString> getTrackNames(bool videoOnly);
     /** @brief Returns the composition A track (MLT index / Track id) */
     QPair<int, int> getCompositionATrack(int cid) const;
     void setCompositionATrack(int cid, int aTrack);
     /* @brief Return true if composition's a_track is automatic (no forced track)
      */
     bool compositionAutoTrack(int cid) const;
     std::shared_ptr<DocUndoStack> undoStack();
     double getClipSpeed(int id) const;
     /** @brief Mark an item as invalid for timeline preview */
     void invalidateItem(ObjectId itemId);
     void invalidateRange(QSize range);
     void prepareShutdown();
     /** the keyframe model changed (effect added, deleted, active effect changed), inform timeline */
     void updateItemKeyframes(ObjectId id);
     /** A fade for clip id changed, update timeline */
     void updateItemModel(ObjectId id, const QString &service);
     /** Show / hide keyframes for a timeline clip */
     void showClipKeyframes(ObjectId id, bool enable);
     Mlt::Profile *thumbProfile();
     /** @brief Returns the current project duration */
     int projectDuration() const;
     /** @brief Returns true if current project has some rendered timeline preview  */
     bool hasTimelinePreview() const;
     /** @brief Returns current timeline cursor position  */
     int getTimelinePosition() const;
     /** @brief Handles audio and video capture **/
     void startMediaCapture(int tid, bool, bool);
     void stopMediaCapture(int tid, bool, bool);
     QStringList getAudioCaptureDevices();
     int getMediaCaptureState();
     bool isMediaCapturing();
     MediaCapture *getAudioDevice();
     /** @brief Returns Project Folder name for capture output location */
     QString getProjectFolderName();
     /** @brief Returns a timeline clip's bin id */
     QString getTimelineClipBinId(int cid);
     /** @brief Returns a frame duration from a timecode */
     int getDurationFromString(const QString &time);
     /** @brief An error occured within a filter, inform user */
     void processInvalidFilter(const QString service, const QString id, const QString message);
     /** @brief Update current project's tags */
     void updateProjectTags(QMap <QString, QString> tags);
     Mlt::Profile *getProjectProfile();
     /** @brief Update MLT's preview profile */
     void updatePreviewProfile();
 
 private:
     explicit Core();
     static std::unique_ptr<Core> m_self;
 
     /** @brief Makes sure Qt's locale and system locale settings match. */
     void initLocale();
 
     MainWindow *m_mainWindow{nullptr};
     ProjectManager *m_projectManager{nullptr};
     MonitorManager *m_monitorManager{nullptr};
     std::shared_ptr<ProjectItemModel> m_projectItemModel;
     std::shared_ptr<JobManager> m_jobManager;
     Bin *m_binWidget{nullptr};
     LibraryWidget *m_library{nullptr};
     MixerManager *m_mixerWidget{nullptr};
     /** @brief Current project's profile path */
     QString m_currentProfile;
 
     QString m_profile;
     std::unique_ptr<Mlt::Profile> m_thumbProfile;
     /** @brief Mlt profile used in project / monitors */
     std::unique_ptr<Mlt::Profile> m_previewProfile;
     bool m_guiConstructed = false;
     /** @brief Check that the profile is valid (width is a multiple of 8 and height a multiple of 2 */
     void checkProfileValidity();
     std::unique_ptr<MediaCapture> m_capture;
     QUrl m_mediaCaptureFile;
     QMutex m_thumbProfileMutex;
 
 public slots:
     void triggerAction(const QString &name);
     /** @brief display a user info/warning message in the project bin */
     void displayBinMessage(const QString &text, int type, const QList<QAction *> &actions = QList<QAction *>());
     void displayBinLogMessage(const QString &text, int type, const QString &logInfo);
     /** @brief Create small thumbnails for luma used in compositions */
     void buildLumaThumbs(const QStringList &values);
 
 signals:
     void coreIsReady();
     void updateLibraryPath();
     void updateMonitorProfile();
     /** @brief Call config dialog on a selected page / tab */
     void showConfigDialog(int, int);
     void finalizeRecording(const QString &captureFile);
     void autoScrollChanged();
 };
 
 #endif
diff --git a/src/main.cpp b/src/main.cpp
index 3b31eb857..afaa5111d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,268 +1,269 @@
 /***************************************************************************
  *   Copyright (C) 2007 by Marco Gittler (g.marco@freenet.de)              *
  *   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 "core.h"
 #include "dialogs/splash.hpp"
 #include "logger.hpp"
 #include <config-kdenlive.h>
 
 #include <mlt++/Mlt.h>
 
 #include "kxmlgui_version.h"
 
 #include <KAboutData>
 #include <KConfigGroup>
 #ifdef USE_DRMINGW
 #include <exchndl.h>
 #elif defined(KF5_USE_CRASH)
 #include <KCrash>
 #endif
 
 #include <KIconLoader>
 #include <KSharedConfig>
 
 #include "definitions.h"
 #include "kdenlive_debug.h"
 #include <KDBusService>
 #include <KIconTheme>
 #include <QResource>
 #include <QApplication>
 #include <QCommandLineOption>
 #include <QCommandLineParser>
 #include <QDir>
 #include <QIcon>
 #include <QProcess>
 #include <QQmlEngine>
 #include <QUrl> //new
 #include <klocalizedstring.h>
 
 #ifdef Q_OS_WIN
 extern "C"
 {
     // Inform the driver we could make use of the discrete gpu
     // __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
     // __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif
 
 
 int main(int argc, char *argv[])
 {
 #ifdef USE_DRMINGW
     ExcHndlInit();
 #endif
     // Force QDomDocument to use a deterministic XML attribute order
     qSetGlobalQHashSeed(0);
 
     Logger::init();
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
     //TODO: is it a good option ?
     QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts, true);
 
 #if defined(Q_OS_UNIX) && !defined(Q_OS_MAC)
     QCoreApplication::setAttribute(Qt::AA_X11InitThreads);
 #elif defined(Q_OS_WIN)
     KSharedConfigPtr configWin = KSharedConfig::openConfig("kdenliverc");
     KConfigGroup grp1(configWin, "misc");
     if (grp1.exists()) {
         int glMode = grp1.readEntry("opengl_backend", 0);
         if (glMode > 0) {
             QCoreApplication::setAttribute((Qt::ApplicationAttribute)glMode, true);
         }
     } else {
         // Default to OpenGLES (QtAngle) on first start
         QCoreApplication::setAttribute(Qt::AA_UseOpenGLES, true);
     }
 #endif
     QApplication app(argc, argv);
     app.setApplicationName(QStringLiteral("kdenlive"));
     app.setOrganizationDomain(QStringLiteral("kde.org"));
     app.setWindowIcon(QIcon(QStringLiteral(":/pics/kdenlive.png")));
     KLocalizedString::setApplicationDomain("kdenlive");
 #ifdef Q_OS_WIN
     qputenv("KDE_FORK_SLAVES", "1");
     QString path = qApp->applicationDirPath() + QLatin1Char(';') + qgetenv("PATH");
     qputenv("PATH", path.toUtf8().constData());
 
     const QStringList themes {"/icons/breeze/breeze-icons.rcc", "/icons/breeze-dark/breeze-icons-dark.rcc"};
     for(const QString theme : themes ) {
         const QString themePath = QStandardPaths::locate(QStandardPaths::AppDataLocation, theme);
         if (!themePath.isEmpty()) {
             const QString iconSubdir = theme.left(theme.lastIndexOf('/'));
             if (QResource::registerResource(themePath, iconSubdir)) {
                 if (QFileInfo::exists(QLatin1Char(':') + iconSubdir + QStringLiteral("/index.theme"))) {
                     qDebug() << "Loaded icon theme:" << theme;
                 } else {
                     qWarning() << "No index.theme found in" << theme;
                     QResource::unregisterResource(themePath, iconSubdir);
                 }
             } else {
                 qWarning() << "Invalid rcc file" << theme;
             }
         }
     }
 #endif
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup grp(config, "unmanaged");
     if (!grp.exists()) {
         QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
         if (env.contains(QStringLiteral("XDG_CURRENT_DESKTOP")) && env.value(QStringLiteral("XDG_CURRENT_DESKTOP")).toLower() == QLatin1String("kde")) {
             qCDebug(KDENLIVE_LOG) << "KDE Desktop detected, using system icons";
         } else {
             // We are not on a KDE desktop, force breeze icon theme
             // Check if breeze theme is available
             QStringList iconThemes = KIconTheme::list();
             if (iconThemes.contains(QStringLiteral("breeze"))) {
                 grp.writeEntry("force_breeze", true);
                 grp.writeEntry("use_dark_breeze", true);
                 qCDebug(KDENLIVE_LOG) << "Non KDE Desktop detected, forcing Breeze icon theme";
             }
         }
         // Set breeze dark as default on first opening
         KConfigGroup cg(config, "UiSettings");
         cg.writeEntry("ColorScheme", "Breeze Dark");
     }
 
     // Init DBus services
     KDBusService programDBusService;
     bool forceBreeze = grp.readEntry("force_breeze", QVariant(false)).toBool();
     if (forceBreeze) {
         bool darkBreeze = grp.readEntry("use_dark_breeze", QVariant(false)).toBool();
         QIcon::setThemeName(darkBreeze ? QStringLiteral("breeze-dark") : QStringLiteral("breeze"));
     }
 
     // Create KAboutData
     KAboutData aboutData(QByteArray("kdenlive"), i18n("Kdenlive"), KDENLIVE_VERSION, i18n("An open source video editor."), KAboutLicense::GPL,
                          i18n("Copyright © 2007–2020 Kdenlive authors"), i18n("Please report bugs to https://bugs.kde.org"),
                          QStringLiteral("https://kdenlive.org"));
     aboutData.addAuthor(i18n("Jean-Baptiste Mardelle"), i18n("MLT and KDE SC 4 / KF5 port, main developer and maintainer"), QStringLiteral("jb@kdenlive.org"));
     aboutData.addAuthor(i18n("Nicolas Carion"), i18n("Code re-architecture & timeline rewrite"), QStringLiteral("french.ebook.lover@gmail.com"));
     aboutData.addAuthor(i18n("Vincent Pinon"), i18n("KF5 port, Windows cross-build, bugs fixing"), QStringLiteral("vpinon@kde.org"));
     aboutData.addAuthor(i18n("Laurent Montel"), i18n("Bugs fixing, clean up code, optimization etc."), QStringLiteral("montel@kde.org"));
     aboutData.addAuthor(i18n("Till Theato"), i18n("Bug fixing, etc."), QStringLiteral("root@ttill.de"));
     aboutData.addAuthor(i18n("Simon A. Eugster"), i18n("Color scopes, bug fixing, etc."), QStringLiteral("simon.eu@gmail.com"));
     aboutData.addAuthor(i18n("Marco Gittler"), i18n("MLT transitions and effects, timeline, audio thumbs"), QStringLiteral("g.marco@freenet.de"));
     aboutData.addAuthor(i18n("Dan Dennedy"), i18n("Bug fixing, etc."), QStringLiteral("dan@dennedy.org"));
     aboutData.addAuthor(i18n("Alberto Villa"), i18n("Bug fixing, logo, etc."), QStringLiteral("avilla@FreeBSD.org"));
     aboutData.addAuthor(i18n("Jean-Michel Poure"), i18n("Rendering profiles customization"), QStringLiteral("jm@poure.com"));
     aboutData.addAuthor(i18n("Ray Lehtiniemi"), i18n("Bug fixing, etc."), QStringLiteral("rayl@mail.com"));
     aboutData.addAuthor(i18n("Steve Guilford"), i18n("Bug fixing, etc."), QStringLiteral("s.guilford@dbplugins.com"));
     aboutData.addAuthor(i18n("Jason Wood"), i18n("Original KDE 3 version author (not active anymore)"), QStringLiteral("jasonwood@blueyonder.co.uk"));
     aboutData.addCredit(i18n("Nara Oliveira and Farid Abdelnour | Estúdio Gunga"), i18n("Kdenlive 16.08 icon"));
     aboutData.setTranslator(i18n("NAME OF TRANSLATORS"), i18n("EMAIL OF TRANSLATORS"));
     aboutData.setOrganizationDomain(QByteArray("kde.org"));
     aboutData.setOtherText(
         i18n("Using:\n<a href=\"https://mltframework.org\">MLT</a> version %1\n<a href=\"https://ffmpeg.org\">FFmpeg</a> libraries", mlt_version_get_string()));
     aboutData.setDesktopFileName(QStringLiteral("org.kde.kdenlive"));
 
     // Register about data
     KAboutData::setApplicationData(aboutData);
 
     // Add rcc stored icons to the search path so that we always find our icons
     KIconLoader *loader = KIconLoader::global();
     loader->reconfigure("kdenlive", QStringList() << QStringLiteral(":/pics"));
 
     // Set app stuff from about data
     app.setApplicationDisplayName(aboutData.displayName());
     app.setOrganizationDomain(aboutData.organizationDomain());
     app.setApplicationVersion(aboutData.version());
     app.setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, true);
 
     // Create command line parser with options
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
     parser.setApplicationDescription(aboutData.shortDescription());
 
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("config"), i18n("Set a custom config file name"), QStringLiteral("config")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("mlt-path"), i18n("Set the path for MLT environment"), QStringLiteral("mlt-path")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("mlt-log"), i18n("MLT log level"), QStringLiteral("verbose/debug")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("i"), i18n("Comma separated list of clips to add"), QStringLiteral("clips")));
     parser.addPositionalArgument(QStringLiteral("file"), i18n("Document to open"));
 
     // Parse command line
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
 #ifdef USE_DRMINGW
     ExcHndlInit();
 #elif defined(KF5_USE_CRASH)
     KCrash::initialize();
 #endif
 
     //auto splash = new Splash(&app);
     //splash->show();
     //qApp->processEvents();
 
     qmlRegisterUncreatableMetaObject(PlaylistState::staticMetaObject, // static meta object
                                      "com.enums",                     // import statement
                                      1, 0,                            // major and minor version of the import
                                      "ClipState",                     // name in QML
                                      "Error: only enums");
     qmlRegisterUncreatableMetaObject(ClipType::staticMetaObject, // static meta object
                                      "com.enums",                // import statement
                                      1, 0,                       // major and minor version of the import
                                      "ProducerType",             // name in QML
                                      "Error: only enums");
     if (parser.value(QStringLiteral("mlt-log")) == QStringLiteral("verbose")) {
         mlt_log_set_level(MLT_LOG_VERBOSE);
     } else if (parser.value(QStringLiteral("mlt-log")) == QStringLiteral("debug")) {
         mlt_log_set_level(MLT_LOG_DEBUG);
     }
+    const QString clipsToLoad = parser.value(QStringLiteral("i"));
     QUrl url;
     if (parser.positionalArguments().count() != 0) {
         url = QUrl::fromLocalFile(parser.positionalArguments().at(0));
         // Make sure we get an absolute URL so that we can autosave correctly
         QString currentPath = QDir::currentPath();
         QUrl startup = QUrl::fromLocalFile(currentPath.endsWith(QDir::separator()) ? currentPath : currentPath + QDir::separator());
         url = startup.resolved(url);
     }
     Core::build(!parser.value(QStringLiteral("config")).isEmpty(), parser.value(QStringLiteral("mlt-path")));
-    pCore->initGUI(url);
+    pCore->initGUI(url, clipsToLoad);
     //delete splash;
     //splash->endSplash();
     //qApp->processEvents();
     int result = app.exec();
     Core::clean();
 
     if (result == EXIT_RESTART || result == EXIT_CLEAN_RESTART) {
         qCDebug(KDENLIVE_LOG) << "restarting app";
         if (result == EXIT_CLEAN_RESTART) {
             // Delete config file
             KSharedConfigPtr config = KSharedConfig::openConfig();
             if (config->name().contains(QLatin1String("kdenlive"))) {
                 // Make sure we delete our config file
                 QFile f(QStandardPaths::locate(QStandardPaths::ConfigLocation, config->name(), QStandardPaths::LocateFile));
                 if (f.exists()) {
                     qDebug()<<" = = = =\nGOT Deleted file: "<<f.fileName();
                     f.remove();
                 }
             }
         }
         QStringList progArgs = QString(*argv).split(QLatin1Char(' '), QString::SkipEmptyParts);
         // Remove app name
         progArgs.takeFirst();
         auto *restart = new QProcess;
         restart->start(app.applicationFilePath(), progArgs);
         restart->waitForReadyRead();
         restart->waitForFinished(1000);
         result = EXIT_SUCCESS;
     }
     return result;
 }