diff --git a/kdevplatform/shell/runtimecontroller.cpp b/kdevplatform/shell/runtimecontroller.cpp
index fb66148cec..e2ad831a05 100644
--- a/kdevplatform/shell/runtimecontroller.cpp
+++ b/kdevplatform/shell/runtimecontroller.cpp
@@ -1,155 +1,165 @@
 /*
    Copyright 2017 Aleix Pol Gonzalez <aleixpol@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "runtimecontroller.h"
 #include <QProcess>
 #include <QComboBox>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KProcess>
 #include <util/path.h>
 #include "core.h"
 #include "uicontroller.h"
 #include "mainwindow.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 class IdentityRuntime : public IRuntime
 {
     QString name() const override { return i18n("Host System"); }
 
     void startProcess(KProcess *process) const override {
-        connect(process, &QProcess::errorOccurred, this, [process](QProcess::ProcessError error) {
+#if QT_VERSION < 0x050600
+        connect(process, static_cast<void(QProcess::*)(QProcess::ProcessError)>(&QProcess::error),
+#else
+        connect(process, &QProcess::errorOccurred,
+#endif
+            this, [process](QProcess::ProcessError error) {
             qCWarning(SHELL) << "error:" << error << process->program() << process->errorString();
         });
         process->start();
     }
     void startProcess(QProcess *process) const override {
-        connect(process, &QProcess::errorOccurred, this, [process](QProcess::ProcessError error) {
+#if QT_VERSION < 0x050600
+        connect(process, static_cast<void(QProcess::*)(QProcess::ProcessError)>(&QProcess::error),
+#else
+        connect(process, &QProcess::errorOccurred,
+#endif
+            this, [process](QProcess::ProcessError error) {
             qCWarning(SHELL) << "error:" << error << process->program() << process->errorString();
         });
         process->start();
     }
     KDevelop::Path pathInHost(const KDevelop::Path & runtimePath) const override { return runtimePath; }
     KDevelop::Path pathInRuntime(const KDevelop::Path & localPath) const override { return localPath; }
     void setEnabled(bool /*enabled*/) override {}
     QByteArray getenv(const QByteArray & varname) const override { return qgetenv(varname); }
 };
 
 KDevelop::RuntimeController::RuntimeController(KDevelop::Core* core)
     : m_core(core)
 {
     const bool haveUI = (core->setupFlags() != Core::NoUi);
     if (haveUI) {
         m_runtimesMenu.reset(new QMenu());
     }
 
     addRuntimes(new IdentityRuntime);
     setCurrentRuntime(m_runtimes.first());
 
     if (haveUI) {
         setupActions();
     }
 }
 
 KDevelop::RuntimeController::~RuntimeController()
 {
     m_currentRuntime->setEnabled(false);
     m_currentRuntime = nullptr;
 }
 
 void RuntimeController::setupActions()
 {
     // TODO not multi-window friendly, FIXME
     KActionCollection* ac = m_core->uiControllerInternal()->defaultMainWindow()->actionCollection();
 
     auto action = new QAction(this);
     action->setStatusTip(i18n("Allows to select a runtime"));
     action->setMenu(m_runtimesMenu.data());
     action->setIcon(QIcon::fromTheme(QStringLiteral("file-library-symbolic")));
     auto updateActionText = [action](IRuntime* currentRuntime){
         action->setText(i18n("Runtime: %1", currentRuntime->name()));
     };
     connect(this, &RuntimeController::currentRuntimeChanged, action, updateActionText);
     updateActionText(m_currentRuntime);
 
     ac->addAction(QStringLiteral("switch_runtimes"), action);
 }
 
 void KDevelop::RuntimeController::initialize()
 {
 }
 
 KDevelop::IRuntime * KDevelop::RuntimeController::currentRuntime() const
 {
     Q_ASSERT(m_currentRuntime);
     return m_currentRuntime;
 }
 
 QVector<KDevelop::IRuntime *> KDevelop::RuntimeController::availableRuntimes() const
 {
     return m_runtimes;
 }
 
 void KDevelop::RuntimeController::setCurrentRuntime(KDevelop::IRuntime* runtime)
 {
     if (m_currentRuntime == runtime)
         return;
 
     Q_ASSERT(m_runtimes.contains(runtime));
 
     if (m_currentRuntime) {
         m_currentRuntime->setEnabled(false);
     }
     qCDebug(SHELL) << "setting runtime..." << runtime->name() << "was" << m_currentRuntime;
     m_currentRuntime = runtime;
     m_currentRuntime->setEnabled(true);
     Q_EMIT currentRuntimeChanged(runtime);
 }
 
 void KDevelop::RuntimeController::addRuntimes(KDevelop::IRuntime * runtime)
 {
     if (!runtime->parent())
         runtime->setParent(this);
 
     if (m_core->setupFlags() != Core::NoUi) {
         QAction* runtimeAction = new QAction(runtime->name(), m_runtimesMenu.data());
         runtimeAction->setCheckable(true);
         connect(runtimeAction, &QAction::triggered, runtime, [this, runtime]() {
             setCurrentRuntime(runtime);
         });
         connect(this, &RuntimeController::currentRuntimeChanged, runtimeAction, [runtimeAction, runtime](IRuntime* currentRuntime) {
             runtimeAction->setChecked(runtime == currentRuntime);
         });
 
         connect(runtime, &QObject::destroyed, this, [this, runtimeAction](QObject* obj) {
             Q_ASSERT(m_currentRuntime != obj);
             m_runtimes.removeAll(qobject_cast<KDevelop::IRuntime *>(obj));
             delete runtimeAction;
         });
         m_runtimesMenu->addAction(runtimeAction);
     } else {
         connect(runtime, &QObject::destroyed, this, [this](QObject* obj) {
             Q_ASSERT(m_currentRuntime != obj);
             m_runtimes.removeAll(qobject_cast<KDevelop::IRuntime *>(obj));
         });
     }
 
     m_runtimes << runtime;
 }
diff --git a/kdevplatform/shell/sourceformattercontroller.cpp b/kdevplatform/shell/sourceformattercontroller.cpp
index 31397296e6..8d9bdc4d1a 100644
--- a/kdevplatform/shell/sourceformattercontroller.cpp
+++ b/kdevplatform/shell/sourceformattercontroller.cpp
@@ -1,665 +1,666 @@
 /* This file is part of KDevelop
 Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #include "sourceformattercontroller.h"
 
 #include <QAction>
+#include <QAbstractButton>
 #include <QMimeDatabase>
 #include <QRegExp>
 #include <QStringList>
 #include <QUrl>
 
 #include <KActionCollection>
 #include <KIO/StoredTransferJob>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KTextEditor/Command>
 #include <KTextEditor/ConfigInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/Editor>
 #include <KTextEditor/View>
 #include <KTextEditor/MainWindow>
 #include <KParts/MainWindow>
 
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/isession.h>
 #include <interfaces/isourceformatter.h>
 #include <interfaces/iuicontroller.h>
 #include <language/codegen/coderepresentation.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <project/projectmodel.h>
 #include <util/path.h>
 
 #include "core.h"
 #include "debug.h"
 #include "plugincontroller.h"
 #include "sourceformatterjob.h"
 
 namespace {
 
 namespace Strings {
 QString SourceFormatter() { return QStringLiteral("SourceFormatter"); }
 QString UseDefault() { return QStringLiteral("UseDefault"); }
 }
 
 }
 
 namespace KDevelop
 {
 
 class SourceFormatterControllerPrivate
 {
 public:
     // GUI actions
     QAction* formatTextAction;
     QAction* formatFilesAction;
     QAction* formatLine;
     QList<KDevelop::ProjectBaseItem*> prjItems;
     QList<QUrl> urls;
     bool enabled = true;
 };
 
 QString SourceFormatterController::kateModeLineConfigKey()
 {
     return QStringLiteral("ModelinesEnabled");
 }
 
 QString SourceFormatterController::kateOverrideIndentationConfigKey()
 {
     return QStringLiteral("OverrideKateIndentation");
 }
 
 QString SourceFormatterController::styleCaptionKey()
 {
     return QStringLiteral("Caption");
 }
 
 QString SourceFormatterController::styleContentKey()
 {
     return QStringLiteral("Content");
 }
 
 QString SourceFormatterController::styleMimeTypesKey()
 {
     return QStringLiteral("MimeTypes");
 }
 
 QString SourceFormatterController::styleSampleKey()
 {
     return QStringLiteral("StyleSample");
 }
 
 SourceFormatterController::SourceFormatterController(QObject *parent)
     : ISourceFormatterController(parent)
     , d(new SourceFormatterControllerPrivate)
 {
     setObjectName(QStringLiteral("SourceFormatterController"));
     setComponentName(QStringLiteral("kdevsourceformatter"), i18n("Source Formatter"));
     setXMLFile(QStringLiteral("kdevsourceformatter.rc"));
 
     if (Core::self()->setupFlags() & Core::NoUi) return;
 
     d->formatTextAction = actionCollection()->addAction(QStringLiteral("edit_reformat_source"));
     d->formatTextAction->setText(i18n("&Reformat Source"));
     d->formatTextAction->setToolTip(i18n("Reformat source using AStyle"));
     d->formatTextAction->setWhatsThis(i18n("Source reformatting functionality using <b>astyle</b> library."));
     connect(d->formatTextAction, &QAction::triggered, this, &SourceFormatterController::beautifySource);
 
     d->formatLine = actionCollection()->addAction(QStringLiteral("edit_reformat_line"));
     d->formatLine->setText(i18n("Reformat Line"));
     d->formatLine->setToolTip(i18n("Reformat current line using AStyle"));
     d->formatLine->setWhatsThis(i18n("Source reformatting of line under cursor using <b>astyle</b> library."));
     connect(d->formatLine, &QAction::triggered, this, &SourceFormatterController::beautifyLine);
 
     d->formatFilesAction = actionCollection()->addAction(QStringLiteral("tools_astyle"));
     d->formatFilesAction->setText(i18n("Reformat Files..."));
     d->formatFilesAction->setToolTip(i18n("Format file(s) using the current theme"));
     d->formatFilesAction->setWhatsThis(i18n("Formatting functionality using <b>astyle</b> library."));
     connect(d->formatFilesAction, &QAction::triggered, this, static_cast<void(SourceFormatterController::*)()>(&SourceFormatterController::formatFiles));
 
     // connect to both documentActivated & documentClosed,
     // otherwise we miss when the last document was closed
     connect(Core::self()->documentController(), &IDocumentController::documentActivated,
             this, &SourceFormatterController::updateFormatTextAction);
     connect(Core::self()->documentController(), &IDocumentController::documentClosed,
             this, &SourceFormatterController::updateFormatTextAction);
     // Use a queued connection, because otherwise the view is not yet fully set up
     connect(Core::self()->documentController(), &IDocumentController::documentLoaded,
             this, &SourceFormatterController::documentLoaded, Qt::QueuedConnection);
 
     updateFormatTextAction();
 }
 
 void SourceFormatterController::documentLoaded( IDocument* doc )
 {
     // NOTE: explicitly check this here to prevent crashes on shutdown
     //       when this slot gets called (note: delayed connection)
     //       but the text document was already destroyed
     //       there have been unit tests that failed due to that...
     if (!doc->textDocument()) {
         return;
     }
     const auto url = doc->url();
     const auto mime = QMimeDatabase().mimeTypeForUrl(url);
     adaptEditorIndentationMode(doc->textDocument(), formatterForUrl(url, mime), url);
 }
 
 void SourceFormatterController::initialize()
 {
 }
 
 SourceFormatterController::~SourceFormatterController()
 {
 }
 
 ISourceFormatter* SourceFormatterController::formatterForUrl(const QUrl &url)
 {
     QMimeType mime = QMimeDatabase().mimeTypeForUrl(url);
     return formatterForUrl(url, mime);
 }
 
 KConfigGroup SourceFormatterController::configForUrl(const QUrl& url) const
 {
     auto core = KDevelop::Core::self();
     auto project = core->projectController()->findProjectForUrl(url);
     if (project) {
         auto config = project->projectConfiguration()->group(Strings::SourceFormatter());
         if (config.isValid() && !config.readEntry(Strings::UseDefault(), true)) {
             return config;
         }
     }
 
     return core->activeSession()->config()->group( Strings::SourceFormatter() );
 }
 
 KConfigGroup SourceFormatterController::sessionConfig() const
 {
     return KDevelop::Core::self()->activeSession()->config()->group( Strings::SourceFormatter() );
 }
 
 KConfigGroup SourceFormatterController::globalConfig() const
 {
     return KSharedConfig::openConfig()->group( Strings::SourceFormatter() );
 }
 
 ISourceFormatter* SourceFormatterController::findFirstFormatterForMimeType(const QMimeType& mime ) const
 {
     static QHash<QString, ISourceFormatter*> knownFormatters;
     if (knownFormatters.contains(mime.name()))
         return knownFormatters[mime.name()];
 
     QList<IPlugin*> plugins = Core::self()->pluginController()->allPluginsForExtension( QStringLiteral("org.kdevelop.ISourceFormatter") );
     foreach( IPlugin* p, plugins) {
         ISourceFormatter *iformatter = p->extension<ISourceFormatter>();
         QSharedPointer<SourceFormatter> formatter(createFormatterForPlugin(iformatter));
         if( formatter->supportedMimeTypes().contains(mime.name()) ) {
             knownFormatters[mime.name()] = iformatter;
             return iformatter;
         }
     }
     knownFormatters[mime.name()] = nullptr;
     return nullptr;
 }
 
 static void populateStyleFromConfigGroup(SourceFormatterStyle* s, const KConfigGroup& stylegrp)
 {
     s->setCaption( stylegrp.readEntry( SourceFormatterController::styleCaptionKey(), QString() ) );
     s->setContent( stylegrp.readEntry( SourceFormatterController::styleContentKey(), QString() ) );
     s->setMimeTypes( stylegrp.readEntry<QStringList>( SourceFormatterController::styleMimeTypesKey(), QStringList() ) );
     s->setOverrideSample( stylegrp.readEntry( SourceFormatterController::styleSampleKey(), QString() ) );
 }
 
 SourceFormatter* SourceFormatterController::createFormatterForPlugin(ISourceFormatter *ifmt) const
 {
     SourceFormatter* formatter = new SourceFormatter();
     formatter->formatter = ifmt;
 
     // Inserted a new formatter. Now fill it with styles
     foreach( const KDevelop::SourceFormatterStyle& style, ifmt->predefinedStyles() ) {
         formatter->styles[ style.name() ] = new SourceFormatterStyle(style);
     }
     KConfigGroup grp = globalConfig();
     if( grp.hasGroup( ifmt->name() ) ) {
         KConfigGroup fmtgrp = grp.group( ifmt->name() );
         foreach( const QString& subgroup, fmtgrp.groupList() ) {
             SourceFormatterStyle* s = new SourceFormatterStyle( subgroup );
             KConfigGroup stylegrp = fmtgrp.group( subgroup );
             populateStyleFromConfigGroup(s, stylegrp);
             formatter->styles[ s->name() ] = s;
         }
     }
     return formatter;
 }
 
 ISourceFormatter* SourceFormatterController::formatterForUrl(const QUrl& url, const QMimeType& mime)
 {
     if (!d->enabled || !isMimeTypeSupported(mime)) {
         return nullptr;
     }
 
     const auto formatter = configForUrl(url).readEntry(mime.name(), QString());
 
     if( formatter.isEmpty() )
     {
         return findFirstFormatterForMimeType( mime );
     }
 
     QStringList formatterinfo = formatter.split( QStringLiteral("||"), QString::SkipEmptyParts );
 
     if( formatterinfo.size() != 2 ) {
         qCDebug(SHELL) << "Broken formatting entry for mime:" << mime.name() << "current value:" << formatter;
         return nullptr;
     }
 
     return Core::self()->pluginControllerInternal()->extensionForPlugin<ISourceFormatter>( QStringLiteral("org.kdevelop.ISourceFormatter"), formatterinfo.at(0) );
 }
 
 bool SourceFormatterController::isMimeTypeSupported(const QMimeType& mime)
 {
     if( findFirstFormatterForMimeType( mime ) ) {
         return true;
     }
     return false;
 }
 
 QString SourceFormatterController::indentationMode(const QMimeType& mime)
 {
     if (mime.inherits(QStringLiteral("text/x-c++src")) || mime.inherits(QStringLiteral("text/x-chdr")) ||
         mime.inherits(QStringLiteral("text/x-c++hdr")) || mime.inherits(QStringLiteral("text/x-csrc")) ||
         mime.inherits(QStringLiteral("text/x-java")) || mime.inherits(QStringLiteral("text/x-csharp"))) {
         return QStringLiteral("cstyle");
     }
     return QStringLiteral("none");
 }
 
 QString SourceFormatterController::addModelineForCurrentLang(QString input, const QUrl& url, const QMimeType& mime)
 {
     if( !isMimeTypeSupported(mime) )
         return input;
 
     QRegExp kateModelineWithNewline("\\s*\\n//\\s*kate:(.*)$");
 
     // If there already is a modeline in the document, adapt it while formatting, even
     // if "add modeline" is disabled.
     if (!configForUrl(url).readEntry(SourceFormatterController::kateModeLineConfigKey(), false) &&
             kateModelineWithNewline.indexIn( input ) == -1 )
         return input;
 
     ISourceFormatter* fmt = formatterForUrl(url, mime);
     ISourceFormatter::Indentation indentation = fmt->indentation(url);
 
     if( !indentation.isValid() )
         return input;
 
     QString output;
     QTextStream os(&output, QIODevice::WriteOnly);
     QTextStream is(&input, QIODevice::ReadOnly);
 
     Q_ASSERT(fmt);
 
 
     QString modeline(QStringLiteral("// kate: ")
                    + QStringLiteral("indent-mode ") + indentationMode(mime) + QStringLiteral("; "));
 
     if(indentation.indentWidth) // We know something about indentation-width
         modeline.append(QStringLiteral("indent-width %1; ").arg(indentation.indentWidth));
 
     if(indentation.indentationTabWidth != 0) // We know something about tab-usage
     {
         modeline.append(QStringLiteral("replace-tabs %1; ").arg(QLatin1String((indentation.indentationTabWidth == -1) ? "on" : "off")));
         if(indentation.indentationTabWidth > 0)
             modeline.append(QStringLiteral("tab-width %1; ").arg(indentation.indentationTabWidth));
     }
 
     qCDebug(SHELL) << "created modeline: " << modeline << endl;
 
     QRegExp kateModeline("^\\s*//\\s*kate:(.*)$");
 
     bool modelinefound = false;
     QRegExp knownOptions("\\s*(indent-width|space-indent|tab-width|indent-mode|replace-tabs)");
     while (!is.atEnd()) {
         QString line = is.readLine();
         // replace only the options we care about
         if (kateModeline.indexIn(line) >= 0) { // match
             qCDebug(SHELL) << "Found a kate modeline: " << line << endl;
             modelinefound = true;
             QString options = kateModeline.cap(1);
             QStringList optionList = options.split(';', QString::SkipEmptyParts);
 
             os <<  modeline;
             foreach(QString s, optionList) {
                 if (knownOptions.indexIn(s) < 0) { // unknown option, add it
                     if(s.startsWith(' '))
                         s=s.mid(1);
                     os << s << ";";
                     qCDebug(SHELL) << "Found unknown option: " << s << endl;
                 }
             }
             os << endl;
         } else
             os << line << endl;
     }
 
     if (!modelinefound)
         os << modeline << endl;
     return output;
 }
 
 void SourceFormatterController::cleanup()
 {
 }
 
 void SourceFormatterController::updateFormatTextAction()
 {
     bool enabled = false;
 
     IDocument* doc = KDevelop::ICore::self()->documentController()->activeDocument();
     if (doc) {
         QMimeType mime = QMimeDatabase().mimeTypeForUrl(doc->url());
         if (isMimeTypeSupported(mime))
             enabled = true;
     }
 
     d->formatLine->setEnabled(enabled);
     d->formatTextAction->setEnabled(enabled);
 }
 
 void SourceFormatterController::beautifySource()
 {
     IDocument* idoc = KDevelop::ICore::self()->documentController()->activeDocument();
     if (!idoc)
         return;
     KTextEditor::View* view = idoc->activeTextView();
     if (!view)
         return;
     KTextEditor::Document* doc = view->document();
     // load the appropriate formatter
     const auto url = idoc->url();
     const auto mime = QMimeDatabase().mimeTypeForUrl(url);
     ISourceFormatter* formatter = formatterForUrl(url, mime);
         if( !formatter ) {
             qCDebug(SHELL) << "no formatter available for" << mime.name();
             return;
         }
 
     // Ignore the modeline, as the modeline will be changed anyway
     adaptEditorIndentationMode(doc, formatter, url, true);
 
     bool has_selection = view->selection();
 
     if (has_selection) {
         QString original = view->selectionText();
 
         QString output = formatter->formatSource(view->selectionText(), url, mime,
                                                 doc->text(KTextEditor::Range(KTextEditor::Cursor(0,0),view->selectionRange().start())),
                                                 doc->text(KTextEditor::Range(view->selectionRange().end(), doc->documentRange().end())));
 
         //remove the final newline character, unless it should be there
         if (!original.endsWith('\n')  && output.endsWith('\n'))
             output.resize(output.length() - 1);
         //there was a selection, so only change the part of the text related to it
 
         // We don't use KTextEditor::Document directly, because CodeRepresentation transparently works
         // around a possible tab-replacement incompatibility between kate and kdevelop
         DynamicCodeRepresentation::Ptr code( dynamic_cast<DynamicCodeRepresentation*>( KDevelop::createCodeRepresentation( IndexedString( doc->url() ) ).data() ) );
         Q_ASSERT( code );
         code->replace( view->selectionRange(), original, output );
     } else {
         formatDocument(idoc, formatter, mime);
     }
 }
 
 void SourceFormatterController::beautifyLine()
 {
     KDevelop::IDocumentController *docController = KDevelop::ICore::self()->documentController();
     KDevelop::IDocument *doc = docController->activeDocument();
     if (!doc || !doc->isTextDocument())
         return;
     KTextEditor::Document *tDoc = doc->textDocument();
     KTextEditor::View* view = doc->activeTextView();
     if (!view)
         return;
     // load the appropriate formatter
     const auto url = doc->url();
     const auto mime = QMimeDatabase().mimeTypeForUrl(url);
     ISourceFormatter* formatter = formatterForUrl(url, mime);
     if( !formatter ) {
         qCDebug(SHELL) << "no formatter available for" << mime.name();
         return;
     }
 
     const KTextEditor::Cursor cursor = view->cursorPosition();
     const QString line = tDoc->line(cursor.line());
     const QString prev = tDoc->text(KTextEditor::Range(0, 0, cursor.line(), 0));
     const QString post = '\n' + tDoc->text(KTextEditor::Range(KTextEditor::Cursor(cursor.line() + 1, 0), tDoc->documentEnd()));
 
     const QString formatted = formatter->formatSource(line, doc->url(), mime, prev, post);
 
     // We don't use KTextEditor::Document directly, because CodeRepresentation transparently works
     // around a possible tab-replacement incompatibility between kate and kdevelop
     DynamicCodeRepresentation::Ptr code(dynamic_cast<DynamicCodeRepresentation*>( KDevelop::createCodeRepresentation( IndexedString( doc->url() ) ).data() ) );
     Q_ASSERT( code );
     code->replace( KTextEditor::Range(cursor.line(), 0, cursor.line(), line.length()), line, formatted );
 
     // advance cursor one line
     view->setCursorPosition(KTextEditor::Cursor(cursor.line() + 1, 0));
 }
 
 void SourceFormatterController::formatDocument(KDevelop::IDocument* doc, ISourceFormatter* formatter, const QMimeType& mime)
 {
     Q_ASSERT(doc);
     Q_ASSERT(formatter);
 
     qCDebug(SHELL) << "Running" << formatter->name() << "on" << doc->url();
 
     // We don't use KTextEditor::Document directly, because CodeRepresentation transparently works
     // around a possible tab-replacement incompatibility between kate and kdevelop
     CodeRepresentation::Ptr code = KDevelop::createCodeRepresentation( IndexedString( doc->url() ) );
 
     KTextEditor::Cursor cursor = doc->cursorPosition();
     QString text = formatter->formatSource(code->text(), doc->url(), mime);
     text = addModelineForCurrentLang(text, doc->url(), mime);
     code->setText(text);
 
     doc->setCursorPosition(cursor);
 }
 
 void SourceFormatterController::settingsChanged()
 {
     foreach (KDevelop::IDocument* doc, ICore::self()->documentController()->openDocuments()) {
         adaptEditorIndentationMode(doc->textDocument(), formatterForUrl(doc->url()), doc->url());
     }
 }
 
 /**
 * Kate commands:
 * Use spaces for indentation:
 *   "set-replace-tabs 1"
 * Use tabs for indentation (eventually mixed):
 *   "set-replace-tabs 0"
 * Indent width:
 * 	 "set-indent-width X"
 * Tab width:
 *   "set-tab-width X"
 * */
 
 void SourceFormatterController::adaptEditorIndentationMode(KTextEditor::Document *doc, ISourceFormatter *formatter,
                                                            const QUrl& url, bool ignoreModeline)
 {
     if (!formatter || !configForUrl(url).readEntry(SourceFormatterController::kateOverrideIndentationConfigKey(), false) || !doc)
         return;
 
     qCDebug(SHELL) << "adapting mode for" << url;
 
     QRegExp kateModelineWithNewline("\\s*\\n//\\s*kate:(.*)$");
 
     // modelines should always take precedence
     if( !ignoreModeline && kateModelineWithNewline.indexIn( doc->text() ) != -1 )
     {
         qCDebug(SHELL) << "ignoring because a kate modeline was found";
         return;
     }
 
     ISourceFormatter::Indentation indentation = formatter->indentation(url);
     if(indentation.isValid())
     {
         struct CommandCaller {
             explicit CommandCaller(KTextEditor::Document* _doc) : doc(_doc), editor(KTextEditor::Editor::instance()) {
                 Q_ASSERT(editor);
             }
             void operator()(const QString& cmd) {
                 KTextEditor::Command* command = editor->queryCommand( cmd );
                 Q_ASSERT(command);
                 QString msg;
                 qCDebug(SHELL) << "calling" << cmd;
                 foreach(KTextEditor::View* view, doc->views())
                     if (!command->exec(view, cmd, msg))
                         qCWarning(SHELL) << "setting indentation width failed: " << msg;
             }
 
             KTextEditor::Document* doc;
             KTextEditor::Editor* editor;
         } call(doc);
 
         if( indentation.indentWidth ) // We know something about indentation-width
             call( QStringLiteral("set-indent-width %1").arg(indentation.indentWidth ) );
 
         if( indentation.indentationTabWidth != 0 ) // We know something about tab-usage
         {
             call( QStringLiteral("set-replace-tabs %1").arg( (indentation.indentationTabWidth == -1) ? 1 : 0 ) );
             if( indentation.indentationTabWidth > 0 )
                 call( QStringLiteral("set-tab-width %1").arg(indentation.indentationTabWidth ) );
         }
     }else{
         qCDebug(SHELL) << "found no valid indentation";
     }
 }
 
 void SourceFormatterController::formatFiles()
 {
     if (d->prjItems.isEmpty() && d->urls.isEmpty())
         return;
 
     //get a list of all files in this folder recursively
     QList<KDevelop::ProjectFolderItem*> folders;
     foreach (KDevelop::ProjectBaseItem *item, d->prjItems) {
         if (!item)
             continue;
         if (item->folder())
             folders.append(item->folder());
         else if (item->file())
             d->urls.append(item->file()->path().toUrl());
         else if (item->target()) {
             foreach(KDevelop::ProjectFileItem *f, item->fileList())
             d->urls.append(f->path().toUrl());
         }
     }
 
     while (!folders.isEmpty()) {
         KDevelop::ProjectFolderItem *item = folders.takeFirst();
         foreach(KDevelop::ProjectFolderItem *f, item->folderList())
         folders.append(f);
         foreach(KDevelop::ProjectTargetItem *f, item->targetList()) {
             foreach(KDevelop::ProjectFileItem *child, f->fileList())
             d->urls.append(child->path().toUrl());
         }
         foreach(KDevelop::ProjectFileItem *f, item->fileList())
         d->urls.append(f->path().toUrl());
     }
 
     auto win = ICore::self()->uiController()->activeMainWindow()->window();
 
     QMessageBox msgBox(QMessageBox::Question, i18n("Reformat files?"),
                        i18n("Reformat all files in the selected folder?"),
                        QMessageBox::Ok|QMessageBox::Cancel, win);
     msgBox.setDefaultButton(QMessageBox::Cancel);
     auto okButton = msgBox.button(QMessageBox::Ok);
     okButton->setText(i18n("Reformat"));
     msgBox.exec();
 
     if (msgBox.clickedButton() == okButton) {
         auto formatterJob = new SourceFormatterJob(this);
         formatterJob->setFiles(d->urls);
         ICore::self()->runController()->registerJob(formatterJob);
     }
 }
 
 KDevelop::ContextMenuExtension SourceFormatterController::contextMenuExtension(KDevelop::Context* context, QWidget* parent)
 {
     Q_UNUSED(parent);
 
     KDevelop::ContextMenuExtension ext;
     d->urls.clear();
     d->prjItems.clear();
 
     if (context->hasType(KDevelop::Context::EditorContext))
     {
         if (d->formatTextAction->isEnabled())
             ext.addAction(KDevelop::ContextMenuExtension::EditGroup, d->formatTextAction);
     } else if (context->hasType(KDevelop::Context::FileContext)) {
         KDevelop::FileContext* filectx = static_cast<KDevelop::FileContext*>(context);
         d->urls = filectx->urls();
         ext.addAction(KDevelop::ContextMenuExtension::EditGroup, d->formatFilesAction);
     } else if (context->hasType(KDevelop::Context::CodeContext)) {
     } else if (context->hasType(KDevelop::Context::ProjectItemContext)) {
         KDevelop::ProjectItemContext* prjctx = static_cast<KDevelop::ProjectItemContext*>(context);
         d->prjItems = prjctx->items();
         if (!d->prjItems.isEmpty()) {
             ext.addAction(KDevelop::ContextMenuExtension::ExtensionGroup, d->formatFilesAction);
         }
     }
     return ext;
 }
 
 SourceFormatterStyle SourceFormatterController::styleForUrl(const QUrl& url, const QMimeType& mime)
 {
     const auto formatter = configForUrl(url).readEntry(mime.name(), QString()).split(QStringLiteral("||"), QString::SkipEmptyParts);
     if( formatter.count() == 2 )
     {
         SourceFormatterStyle s( formatter.at( 1 ) );
         KConfigGroup fmtgrp = globalConfig().group( formatter.at(0) );
         if( fmtgrp.hasGroup( formatter.at(1) ) ) {
             KConfigGroup stylegrp = fmtgrp.group( formatter.at(1) );
             populateStyleFromConfigGroup(&s, stylegrp);
         }
         return s;
     }
     return SourceFormatterStyle();
 }
 
 void SourceFormatterController::disableSourceFormatting(bool disable)
 {
     d->enabled = !disable;
 }
 
 bool SourceFormatterController::sourceFormattingEnabled()
 {
     return d->enabled;
 }
 
 }
diff --git a/plugins/cmake/cmakecommandscontents.cpp b/plugins/cmake/cmakecommandscontents.cpp
index d8566b35cb..d6d99c6216 100644
--- a/plugins/cmake/cmakecommandscontents.cpp
+++ b/plugins/cmake/cmakecommandscontents.cpp
@@ -1,182 +1,182 @@
 /* KDevelop CMake Support
  *
  * Copyright 2009 Aleix Pol <aleixpol@kde.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 "cmakecommandscontents.h"
 #include <interfaces/iruntimecontroller.h>
 #include <interfaces/iruntime.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentation.h>
 #include <interfaces/idocumentationcontroller.h>
 #include "cmakebuilderconfig.h"
 #include "cmakedoc.h"
 #include <QProcess>
 #include <KLocalizedString>
 
-static const QVector<QLatin1String> args = {
-    QLatin1String("--help-command"), QLatin1String("--help-variable"), QLatin1String("--help-module"), QLatin1String("--help-property"), QLatin1String(), QLatin1String()
+static const QVector<QString> args = {
+    QLatin1String("--help-command"), QLatin1String("--help-variable"), QLatin1String("--help-module"), QLatin1String("--help-property"), QString(), QString()
 };
 static QString modules [] = {
     i18n("Commands"), i18n("Variables"), i18n("Modules"), i18n("Properties"), i18n("Policies")
 };
 
 CMakeCommandsContents::CMakeCommandsContents(QObject* parent)
      : QAbstractItemModel(parent)
      , m_namesForType(CMakeDocumentation::EOType)
 {
     QVector<QProcess*> processes;
     for(int i=0; i<=CMakeDocumentation::Property; i++) {
         const QStringList params = { args[i]+QStringLiteral("-list") };
 
         QProcess* process = new QProcess(this);
         process->setProperty("type", i);
         process->setProgram(CMakeBuilderSettings::self()->cmakeExecutable().toLocalFile());
         process->setArguments(params);
         KDevelop::ICore::self()->runtimeController()->currentRuntime()->startProcess(process);
 
         connect(process, static_cast<void(QProcess::*)(int)>(&QProcess::finished), this, &CMakeCommandsContents::processOutput);
     }
 }
 
 void CMakeCommandsContents::processOutput(int code)
 {
     QProcess* process = qobject_cast<QProcess*>(sender());
     if (code!=0) {
         qDebug() << "failed" << process;
         return;
     }
 
     const CMakeDocumentation::Type type = CMakeDocumentation::Type(process->property("type").toInt());
 
     QTextStream stream(process);
     QString line = stream.readLine(); //discard first line
     QMap<QString, CMakeDocumentation::Type> newEntries;
     QVector<QString> names;
     while(stream.readLineInto(&line)) {
         newEntries[line]=type;
         names += line;
     }
 
     beginInsertRows(index(type, 0, {}), 0, names.count()-1);
     m_typeForName.unite(newEntries);
     m_namesForType[type] = names;
     endInsertRows();
 }
 
 CMakeDocumentation::Type CMakeCommandsContents::typeFor(const QString& identifier) const
 {
     //TODO can do much better
     if(m_typeForName.contains(identifier)) {
         return m_typeForName[identifier];
     } else if(m_typeForName.contains(identifier.toLower())) {
         return m_typeForName[identifier.toLower()];
     } else if(m_typeForName.contains(identifier.toUpper())) {
         return m_typeForName[identifier.toUpper()];
     }
     return CMakeDocumentation::EOType;
 }
 
 QString CMakeCommandsContents::descriptionForIdentifier(const QString& id, CMakeDocumentation::Type t) const
 {
     QString desc;
     if(args[t].size() != 0) {
         desc = CMake::executeProcess(CMakeBuilderSettings::self()->cmakeExecutable().toLocalFile(), { args[t], id.simplified() });
         desc = desc.remove(QStringLiteral(":ref:"));
 
         const QString rst2html = QStandardPaths::findExecutable(QStringLiteral("rst2html"));
         if (rst2html.isEmpty()) {
             desc = ("<html><body style='background:#fff'><pre><code>" + desc.toHtmlEscaped() + "</code></pre>"
                 + i18n("<p>For better cmake documentation rendering, install rst2html</p>")
                 + "</body></html>");
         } else {
             QProcess p;
             p.start(rst2html, { "--no-toc-backlinks" });
             p.write(desc.toUtf8());
             p.closeWriteChannel();
             p.waitForFinished();
             desc = QString::fromUtf8(p.readAllStandardOutput());
         }
     }
 
     return desc;
 }
 
 
 void CMakeCommandsContents::showItemAt(const QModelIndex& idx) const
 {
     if(idx.isValid() && int(idx.internalId())>=0) {
         QString desc=CMakeDoc::s_provider->descriptionForIdentifier(idx.data().toString(),
                                                                     (ICMakeDocumentation::Type) idx.parent().row());
         CMakeDoc::Ptr doc(new CMakeDoc(idx.data().toString(), desc));
 
         KDevelop::ICore::self()->documentationController()->showDocumentation(doc);
     }
 }
 
 QModelIndex CMakeCommandsContents::parent(const QModelIndex& child) const
 {
     if(child.isValid() && child.column()==0 && int(child.internalId())>=0)
         return createIndex(child.internalId(),0, -1);
     return QModelIndex();
 }
 
 QModelIndex CMakeCommandsContents::index(int row, int column, const QModelIndex& parent) const
 {
     if(row<0 || column!=0)
         return QModelIndex();
     if(!parent.isValid() && row==ICMakeDocumentation::EOType)
         return QModelIndex();
 
     return createIndex(row,column, int(parent.isValid() ? parent.row() : -1));
 }
 
 int CMakeCommandsContents::rowCount(const QModelIndex& parent) const
 {
     if(!parent.isValid())
         return ICMakeDocumentation::EOType;
     else if(int(parent.internalId())<0) {
         int ss=names((ICMakeDocumentation::Type) parent.row()).size();
         return ss;
     }
     return 0;
 }
 
 QVariant CMakeCommandsContents::data(const QModelIndex& index, int role) const
 {
     if (index.isValid()) {
         if(role==Qt::DisplayRole) {
             int internal(index.internalId());
             if(internal>=0)
                 return m_namesForType[internal].count() > index.row() ? QVariant(m_namesForType[internal].at(index.row())) : QVariant();
             else
                 return modules[index.row()];
         }
     }
     return QVariant();
 }
 
 int CMakeCommandsContents::columnCount(const QModelIndex& /*parent*/) const
 {
     return 1;
 }
 
 QVector<QString> CMakeCommandsContents::names(ICMakeDocumentation::Type t) const
 {
     return m_namesForType[t];
 }
diff --git a/plugins/projectmanagerview/cutcopypastehelpers.cpp b/plugins/projectmanagerview/cutcopypastehelpers.cpp
index 0dad90fc79..51cdd6982f 100644
--- a/plugins/projectmanagerview/cutcopypastehelpers.cpp
+++ b/plugins/projectmanagerview/cutcopypastehelpers.cpp
@@ -1,350 +1,350 @@
 /*  This file is part of KDevelop
     Copyright (C) 2017  Alexander Potashev <aspotashev@gmail.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "cutcopypastehelpers.h"
 
 #include <QTreeWidget>
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QStyle>
 #include <QStyleOption>
 #include <QPointer>
 #include <QAbstractButton>
 
 #include <KLocalizedString>
 #include <KIO/DeleteJob>
 
 #include <interfaces/icore.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <serialization/indexedstring.h>
 
 using namespace KDevelop;
 
 namespace CutCopyPasteHelpers
 {
 
 TaskInfo::TaskInfo(const TaskStatus status, const TaskType type,
                    const Path::List& src, const Path& dest)
     : m_status(status),
       m_type(type),
       m_src(src),
       m_dest(dest)
 {
 }
 
 TaskInfo TaskInfo::createMove(const bool ok, const Path::List& src, const Path& dest)
 {
     return TaskInfo(ok ? TaskStatus::SUCCESS : TaskStatus::FAILURE,
                     TaskType::MOVE, src, dest);
 }
 
 TaskInfo TaskInfo::createCopy(const bool ok, const Path::List& src, const Path& dest)
 {
     return TaskInfo(ok ? TaskStatus::SUCCESS : TaskStatus::FAILURE,
                     TaskType::COPY, src, dest);
 }
 
 TaskInfo TaskInfo::createDeletion(const bool ok, const Path::List& src, const Path& dest)
 {
     return TaskInfo(ok ? TaskStatus::SUCCESS : TaskStatus::FAILURE,
                     TaskType::DELETION, src, dest);
 }
 
 static QWidget* createPasteStatsWidget(QWidget *parent, const QVector<TaskInfo>& tasks)
 {
     // TODO: Create a model for the task list, and use it here instead of using QTreeWidget
     QTreeWidget* treeWidget = new QTreeWidget(parent);
     QList<QTreeWidgetItem *> items;
     for (const TaskInfo& task : tasks) {
         int srcCount = task.m_src.size();
         const bool withChildren = srcCount != 1;
 
         const QString destPath = task.m_dest.pathOrUrl();
 
         QString text;
         if (withChildren) {
             // Multiple source items in the current suboperation
             switch (task.m_type) {
                 case TaskType::MOVE:
                     text = i18np("Move %1 item into %2", "Move %1 items into %2", srcCount, destPath);
                     break;
                 case TaskType::COPY:
                     text = i18np("Copy %1 item into %2", "Copy %1 items into %2", srcCount, destPath);
                     break;
                 case TaskType::DELETION:
                     text = i18np("Delete %1 item", "Delete %1 items", srcCount);
                     break;
             }
         } else {
             // One source item in the current suboperation
             const QString srcPath = task.m_src[0].pathOrUrl();
 
             switch (task.m_type) {
                 case TaskType::MOVE:
                     text = i18n("Move item %1 into %2", srcPath, destPath);
                     break;
                 case TaskType::COPY:
                     text = i18n("Copy item %1 into %2", srcPath, destPath);
                     break;
                 case TaskType::DELETION:
                     text = i18n("Delete item %1", srcPath);
                     break;
             }
         }
 
         QString tooltip;
         QString iconName;
         switch (task.m_status) {
             case TaskStatus::SUCCESS:
                 tooltip = i18n("Suboperation succeeded");
                 iconName = QStringLiteral("dialog-ok");
                 break;
             case TaskStatus::FAILURE:
                 tooltip = i18n("Suboperation failed");
                 iconName = QStringLiteral("dialog-error");
                 break;
             case TaskStatus::SKIPPED:
                 tooltip = i18n("Suboperation skipped to prevent data loss");
                 iconName = QStringLiteral("dialog-warning");
                 break;
         }
 
         QTreeWidgetItem* item = new QTreeWidgetItem;
         item->setText(0, text);
         item->setIcon(0, QIcon::fromTheme(iconName));
         item->setToolTip(0, tooltip);
         items.append(item);
 
         if (withChildren) {
             for (const Path& src : task.m_src) {
                 QTreeWidgetItem* childItem = new QTreeWidgetItem;
                 childItem->setText(0, src.pathOrUrl());
                 item->addChild(childItem);
             }
         }
     }
     treeWidget->insertTopLevelItems(0, items);
     treeWidget->headerItem()->setHidden(true);
 
     return treeWidget;
 }
 
 SourceToDestinationMap mapSourceToDestination(const Path::List& sourcePaths, const Path& destinationPath)
 {
     // For example you are moving the following items into /dest/
     //   * /tests/
     //   * /tests/abc.cpp
     // If you pass them as is, moveFilesAndFolders() will crash (see note:
     // "Do not attempt to move subitems along with their parents").
     // Thus we filter out subitems from "Path::List filteredPaths".
     //
     // /tests/abc.cpp will be implicitly moved to /dest/tests/abc.cpp, for
     // that reason we add "/dest/tests/abc.cpp" into "result.finalPaths" as well as
     // "/dest/tests".
     //
     // "result.finalPaths" will be used to highlight destination items after
     // copy/move.
     Path::List sortedPaths = sourcePaths;
     std::sort(sortedPaths.begin(), sortedPaths.end());
 
     SourceToDestinationMap result;
     for (const Path& path : sortedPaths) {
-        if (!result.filteredPaths.isEmpty() && result.filteredPaths.rbegin()->isParentOf(path)) {
+        if (!result.filteredPaths.isEmpty() && std::reverse_iterator<Path::List::const_iterator>(result.filteredPaths.constBegin())->isParentOf(path)) {
             // think: "/tests"
-            const Path& previousPath = *result.filteredPaths.rbegin();
+            const Path& previousPath = *std::reverse_iterator<Path::List::const_iterator>(result.filteredPaths.constBegin());
             // think: "/dest" + "/".relativePath("/tests/abc.cpp") = /dest/tests/abc.cpp
             result.finalPaths[previousPath].append(Path(destinationPath, previousPath.parent().relativePath(path)));
         } else {
             // think: "/tests"
             result.filteredPaths.append(path);
             // think: "/dest" + "tests" = "/dest/tests"
             result.finalPaths[path].append(Path(destinationPath, path.lastPathSegment()));
         }
     }
 
     return result;
 }
 
 struct ClassifiedPaths
 {
     // Items originating from projects open in this KDevelop session
     QHash<IProject*, QList<KDevelop::ProjectBaseItem*>> itemsPerProject;
     // Items that do not belong to known projects
     Path::List alienSrcPaths;
 };
 
 static ClassifiedPaths classifyPaths(const Path::List& paths, KDevelop::ProjectModel* projectModel)
 {
     ClassifiedPaths result;
     for (const Path& path : paths) {
         QList<ProjectBaseItem*> items = projectModel->itemsForPath(IndexedString(path.path()));
         if (!items.empty()) {
             for (ProjectBaseItem* item : items) {
                 IProject* project = item->project();
                 if (!result.itemsPerProject.contains(project)) {
                     result.itemsPerProject[project] = QList<KDevelop::ProjectBaseItem*>();
                 }
 
                 result.itemsPerProject[project].append(item);
             }
         } else {
             result.alienSrcPaths.append(path);
         }
     }
 
     return result;
 }
 
 QVector<TaskInfo> copyMoveItems(const Path::List& paths, ProjectBaseItem* destItem, const Operation operation)
 {
     KDevelop::ProjectModel* projectModel = KDevelop::ICore::self()->projectController()->projectModel();
     const ClassifiedPaths cl = classifyPaths(paths, projectModel);
 
     QVector<TaskInfo> tasks;
 
     IProject* destProject = destItem->project();
     IProjectFileManager* destProjectFileManager = destProject->projectFileManager();
     ProjectFolderItem* destFolder = destItem->folder();
     Path destPath = destFolder->path();
     for (IProject* srcProject : cl.itemsPerProject.keys()) {
         const auto& itemsList = cl.itemsPerProject[srcProject];
 
         Path::List pathsList;
         for (KDevelop::ProjectBaseItem* item : itemsList) {
             pathsList.append(item->path());
         }
 
         if (srcProject == destProject) {
             if (operation == Operation::CUT) {
                 // Move inside project
                 const bool ok = destProjectFileManager->moveFilesAndFolders(itemsList, destFolder);
                 tasks.append(TaskInfo::createMove(ok, pathsList, destPath));
             } else {
                 // Copy inside project
                 const bool ok = destProjectFileManager->copyFilesAndFolders(pathsList, destFolder);
                 tasks.append(TaskInfo::createCopy(ok, pathsList, destPath));
             }
         } else {
             // Copy/move between projects:
             //  1. Copy and add into destination project;
             //  2. Remove from source project.
             const bool copy_ok = destProjectFileManager->copyFilesAndFolders(pathsList, destFolder);
             tasks.append(TaskInfo::createCopy(copy_ok, pathsList, destPath));
 
             if (operation == Operation::CUT) {
                 if (copy_ok) {
                     IProjectFileManager* srcProjectFileManager = srcProject->projectFileManager();
                     const bool deletion_ok = srcProjectFileManager->removeFilesAndFolders(itemsList);
                     tasks.append(TaskInfo::createDeletion(deletion_ok, pathsList, destPath));
                 } else {
                     tasks.append(TaskInfo(TaskStatus::SKIPPED, TaskType::DELETION, pathsList, destPath));
                 }
             }
         }
     }
 
     // Copy/move items from outside of all open projects
     if (!cl.alienSrcPaths.isEmpty()) {
         const bool alien_copy_ok = destProjectFileManager->copyFilesAndFolders(cl.alienSrcPaths, destFolder);
         tasks.append(TaskInfo::createCopy(alien_copy_ok, cl.alienSrcPaths, destPath));
 
         if (operation == Operation::CUT) {
             if (alien_copy_ok) {
                 QList<QUrl> urlsToDelete;
                 for (const Path& path : cl.alienSrcPaths) {
                     urlsToDelete.append(path.toUrl());
                 }
 
                 KIO::DeleteJob* deleteJob = KIO::del(urlsToDelete);
                 const bool deletion_ok = deleteJob->exec();
                 tasks.append(TaskInfo::createDeletion(deletion_ok, cl.alienSrcPaths, destPath));
             } else {
                 tasks.append(TaskInfo(TaskStatus::SKIPPED, TaskType::DELETION, cl.alienSrcPaths, destPath));
             }
         }
     }
 
     return tasks;
 }
 
 void showWarningDialogForFailedPaste(QWidget* parent, const QVector<TaskInfo>& tasks)
 {
     QDialog* dialog = new QDialog(parent);
 
     dialog->setWindowTitle(i18nc("@title:window", "Paste Failed"));
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(dialog);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok);
     QObject::connect(buttonBox, &QDialogButtonBox::clicked, dialog, &QDialog::accept);
 
     dialog->setWindowModality(Qt::WindowModal);
     dialog->setModal(true);
 
     QWidget* mainWidget = new QWidget(dialog);
     QVBoxLayout* mainLayout = new QVBoxLayout(mainWidget);
     const int spacingHint = mainWidget->style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     mainLayout->setSpacing(spacingHint * 2); // provide extra spacing
     mainLayout->setMargin(0);
 
     QHBoxLayout* hLayout = new QHBoxLayout;
     hLayout->setMargin(0);
     hLayout->setSpacing(-1); // use default spacing
     mainLayout->addLayout(hLayout, 0);
 
     QLabel* iconLabel = new QLabel(mainWidget);
 
     // Icon
     QStyleOption option;
     option.initFrom(mainWidget);
     QIcon icon = QIcon::fromTheme(QStringLiteral("dialog-warning"));
     iconLabel->setPixmap(icon.pixmap(mainWidget->style()->pixelMetric(QStyle::PM_MessageBoxIconSize, &option, mainWidget)));
 
     QVBoxLayout* iconLayout = new QVBoxLayout();
     iconLayout->addStretch(1);
     iconLayout->addWidget(iconLabel);
     iconLayout->addStretch(5);
 
     hLayout->addLayout(iconLayout, 0);
     hLayout->addSpacing(spacingHint);
 
     const QString text = i18n("Failed to paste. Below is a list of suboperations that have been attempted.");
     QLabel* messageLabel = new QLabel(text, mainWidget);
     messageLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
     hLayout->addWidget(messageLabel, 5);
 
     QWidget* statsWidget = createPasteStatsWidget(dialog, tasks);
 
     QVBoxLayout* topLayout = new QVBoxLayout;
     dialog->setLayout(topLayout);
     topLayout->addWidget(mainWidget);
     topLayout->addWidget(statsWidget, 1);
     topLayout->addWidget(buttonBox);
 
     dialog->setMinimumSize(300, qMax(150, qMax(iconLabel->sizeHint().height(), messageLabel->sizeHint().height())));
 
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     dialog->show();
 }
 
 } // namespace CutCopyPasteHelpers