diff --git a/debugger/variable/variablewidget.cpp b/debugger/variable/variablewidget.cpp
index 2cb3b7162..c0c1a2155 100644
--- a/debugger/variable/variablewidget.cpp
+++ b/debugger/variable/variablewidget.cpp
@@ -1,512 +1,512 @@
 // **************************************************************************
 //    begin                : Sun Aug 8 1999
 //    copyright            : (C) 1999 by John Birch
 //    email                : jbb@kdevelop.org
 // **************************************************************************
 // * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
 // **************************************************************************
 // *                                                                        *
 // *   This program is free software; you can redistribute it and/or modify *
 // *   it under the terms of the GNU General Public License as published by *
 // *   the Free Software Foundation; either version 2 of the License, or    *
 // *   (at your option) any later version.                                  *
 // *                                                                        *
 // **************************************************************************
 
 #include "variablewidget.h"
 
 #include <QApplication>
 #include <QCursor>
 #include <QClipboard>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QVBoxLayout>
 
 #include <KHistoryComboBox>
 #include <KLocalizedString>
 #include <QSortFilterProxyModel>
 
 #include "../util/treemodel.h"
 #include "../../interfaces/icore.h"
 #include <interfaces/idebugcontroller.h>
 #include "../interfaces/ivariablecontroller.h"
 #include "variablecollection.h"
 #include "variablesortmodel.h"
 #include "util/debug.h"
 
 /** The variables widget is passive, and is invoked by the rest of the
     code via two main Q_SLOTS:
     - slotDbgStatus
     - slotCurrentFrame
 
     The first is received the program status changes and the second is
     received after current frame in the debugger can possibly changes.
 
     The widget has a list item for each frame/thread combination, with
     variables as children. However, at each moment only one item is shown.
     When handling the slotCurrentFrame, we check if variables for the
     current frame are available. If yes, we simply show the corresponding item.
     Otherwise, we fetch the new data from debugger.
 
     Fetching the data is done by emitting the produceVariablesInfo signal.
     In response, we get slotParametersReady and slotLocalsReady signal,
     in that order.
 
     The data is parsed and changed variables are highlighted. After that,
     we 'trim' variable items that were not reported by gdb -- that is, gone
     out of scope.
 */
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 namespace KDevelop
 {
 
 VariableCollection *variableCollection()
 {
     return ICore::self()->debugController()->variableCollection();
 }
 
 
 VariableWidget::VariableWidget(IDebugController* controller, QWidget *parent)
 : QWidget(parent), variablesRoot_(controller->variableCollection()->root())
 {
   //setWindowIcon(QIcon::fromTheme("math_brace"));
     setWindowIcon(QIcon::fromTheme(QStringLiteral("debugger"), windowIcon()));
     setWindowTitle(i18n("Debugger Variables"));
 
-    m_proxy = new VariableSortProxyModel;
+    m_proxy = new VariableSortProxyModel(this);
     varTree_ = new VariableTree(controller, this, m_proxy);
     setFocusProxy(varTree_);
 
     watchVarEditor_ = new KHistoryComboBox( this );
 
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     topLayout->addWidget(varTree_, 10);
     topLayout->addWidget(watchVarEditor_);
     topLayout->setMargin(0);
 
     connect(watchVarEditor_, static_cast<void(KHistoryComboBox::*)(const QString&)>(&KHistoryComboBox::returnPressed),
             this, &VariableWidget::slotAddWatch);
 
     //TODO
     //connect(plugin, SIGNAL(raiseVariableViews()), this, SIGNAL(requestRaise()));
 
     // Setup help items.
 
     setWhatsThis( i18n(
         "<b>Variable tree</b>"
         "The variable tree allows you to see the values of local "
         "variables and arbitrary expressions.<br />"
         "Local variables are displayed automatically and are updated "
         "as you step through your program. "
         "For each expression you enter, you can either evaluate it once, "
         "or \"watch\" it (make it auto-updated). Expressions that are not "
         "auto-updated can be updated manually from the context menu. "
         "Expressions can be renamed to more descriptive names by clicking "
         "on the name column.<br />"
         "To change the value of a variable or an expression, "
         "click on the value.<br />"));
 
     watchVarEditor_->setWhatsThis(
                     i18n("<b>Expression entry</b>"
                          "Type in expression to watch."));
 
 }
 
 void VariableWidget::slotAddWatch(const QString &expression)
 {
     if (!expression.isEmpty())
     {
         watchVarEditor_->addToHistory(expression);
         qCDebug(DEBUGGER) << "Trying to add watch";
         Variable* v = variablesRoot_->watches()->add(expression);
         if (v) {
             /* For watches on structures, we really do want them to be shown
             expanded.  Except maybe for structure with custom pretty printing,
             but will handle that later.
             FIXME: it does not actually works now.
             */
             //QModelIndex index = variableCollection()->indexForItem(v, 0);
             //varTree_->setExpanded(index, true);
         }
         watchVarEditor_->clearEditText();
     }
 }
 
 void VariableWidget::hideEvent(QHideEvent* e)
 {
     QWidget::hideEvent(e);
     variableCollection()->variableWidgetHidden();
 }
 
 void VariableWidget::showEvent(QShowEvent* e)
 {
     QWidget::showEvent(e);
     variableCollection()->variableWidgetShown();
 }
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 VariableTree::VariableTree(IDebugController *controller,
                            VariableWidget *parent, QSortFilterProxyModel *proxy)
     : AsyncTreeView(controller->variableCollection(), proxy, parent)
     , m_proxy(proxy)
 #if 0
 ,
       activePopup_(0),
       toggleWatch_(0)
 #endif
 {
     setRootIsDecorated(true);
     setAllColumnsShowFocus(true);
 
     // setting proxy model
     m_model = static_cast<TreeModel *>(controller->variableCollection());
     m_proxy->setSourceModel(m_model);
     setModel(m_proxy);
     setSortingEnabled(true);
     sortByColumn(VariableCollection::NameColumn, Qt::AscendingOrder);
 
     QModelIndex index = controller->variableCollection()->indexForItem(
         controller->variableCollection()->watches(), 0);
     setExpanded(index, true);
 
     m_signalMapper = new QSignalMapper(this);
     setupActions();
 }
 
 
 VariableCollection* VariableTree::collection() const
 {
     Q_ASSERT(qobject_cast<VariableCollection*>(static_cast<QSortFilterProxyModel*>(model())->sourceModel()));
     return static_cast<VariableCollection*>(model());
 }
 
 
 VariableTree::~VariableTree()
 {
 }
 
 void VariableTree::setupActions()
 {
     // TODO decorate this properly to make nice menu title
     m_contextMenuTitle = new QAction(this);
     m_contextMenuTitle->setEnabled(false);
 
     // make Format menu action group
     m_formatMenu = new QMenu(i18n("&Format"), this);
     QActionGroup *ag= new QActionGroup(m_formatMenu);
 
     QAction* act;
 
     act = new QAction(i18n("&Natural"), ag);
     act->setData(Variable::Natural);
     act->setShortcut(Qt::Key_N);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Binary"), ag);
     act->setData(Variable::Binary);
     act->setShortcut(Qt::Key_B);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Octal"), ag);
     act->setData(Variable::Octal);
     act->setShortcut(Qt::Key_O);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Decimal"), ag);
     act->setData(Variable::Decimal);
     act->setShortcut(Qt::Key_D);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Hexadecimal"), ag);
     act->setData(Variable::Hexadecimal);
     act->setShortcut(Qt::Key_H);
     m_formatMenu->addAction(act);
 
     foreach(QAction* act, m_formatMenu->actions())
     {
         act->setCheckable(true);
         act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         m_signalMapper->setMapping(act, act->data().toInt());
         connect(act, &QAction::triggered, m_signalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
         addAction(act);
     }
     connect(m_signalMapper, static_cast<void(QSignalMapper::*)(int)>(&QSignalMapper::mapped), this, &VariableTree::changeVariableFormat);
 
     m_watchDelete = new QAction(
         QIcon::fromTheme(QStringLiteral("edit-delete")), i18n( "Remove Watch Variable" ), this);
 
     m_watchDelete->setShortcut(Qt::Key_Delete);
     m_watchDelete->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     addAction(m_watchDelete);
     connect(m_watchDelete, &QAction::triggered, this, &VariableTree::watchDelete);
 
     m_copyVariableValue = new QAction(i18n("&Copy Value"), this);
     m_copyVariableValue->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     m_copyVariableValue->setShortcut(QKeySequence::Copy);
     connect(m_copyVariableValue, &QAction::triggered, this, &VariableTree::copyVariableValue);
 
     m_stopOnChange = new QAction(i18n("&Stop on Change"), this);
     connect(m_stopOnChange, &QAction::triggered, this, &VariableTree::stopOnChange);
 }
 
 Variable* VariableTree::selectedVariable() const
 {
     if (selectionModel()->selectedRows().isEmpty()) return 0;
     auto item = selectionModel()->currentIndex().data(TreeModel::ItemRole).value<TreeItem*>();
     if (!item) return 0;
     return dynamic_cast<Variable*>(item);
 }
 
 void VariableTree::contextMenuEvent(QContextMenuEvent* event)
 {
     if (!selectedVariable()) return;
 
     // set up menu
     QMenu contextMenu(this->parentWidget());
     m_contextMenuTitle->setText(selectedVariable()->expression());
     contextMenu.addAction(m_contextMenuTitle);
 
     if(selectedVariable()->canSetFormat())
         contextMenu.addMenu(m_formatMenu);
 
     foreach(QAction* act, m_formatMenu->actions()) {
         if(act->data().toInt()==selectedVariable()->format())
             act->setChecked(true);
     }
 
     if (dynamic_cast<Watches*>(selectedVariable()->parent())) {
         contextMenu.addAction(m_watchDelete);
     }
 
     contextMenu.addSeparator();
     contextMenu.addAction(m_copyVariableValue);
     contextMenu.addAction(m_stopOnChange);
 
     contextMenu.exec(event->globalPos());
 }
 
 void VariableTree::changeVariableFormat(int format)
 {
     if (!selectedVariable()) return;
     selectedVariable()->setFormat(static_cast<Variable::format_t>(format));
 }
 
 void VariableTree::watchDelete()
 {
     if (!selectedVariable()) return;
     if (!dynamic_cast<Watches*>(selectedVariable()->parent())) return;
     selectedVariable()->die();
 }
 
 void VariableTree::copyVariableValue()
 {
     if (!selectedVariable()) return;
     QApplication::clipboard()->setText(selectedVariable()->value());
 }
 
 void VariableTree::stopOnChange()
 {
     if (!selectedVariable()) return;
     IDebugSession *session = ICore::self()->debugController()->currentSession();
     if (session && session->state() != IDebugSession::NotStartedState && session->state() != IDebugSession::EndedState) {
         session->variableController()->addWatchpoint(selectedVariable());
     }
 }
 
 #if 0
 void VariableTree::contextMenuEvent(QContextMenuEvent* event)
 {
     QModelIndex index = indexAt(event->pos());
     if (!index.isValid())
         return;
 
     AbstractVariableItem* item = collection()->itemForIndex(index);
 
     if (RecentItem* recent = qobject_cast<RecentItem*>(item))
     {
         QMenu popup(this);
         popup.addTitle(i18n("Recent Expressions"));
         QAction* remove = popup.addAction(QIcon::fromTheme("editdelete"), i18n("Remove All"));
         QAction* reevaluate = popup.addAction(QIcon::fromTheme("reload"), i18n("Re-evaluate All"));
 
         if (controller()->stateIsOn(s_dbgNotStarted))
             reevaluate->setEnabled(false);
 
         QAction* res = popup.exec(QCursor::pos());
 
         if (res == remove)
         {
             collection()->deleteItem(recent);
         }
         else if (res == reevaluate)
         {
             foreach (AbstractVariableItem* item, recent->children())
             {
                 if (VariableItem* variable = qobject_cast<VariableItem*>(item))
                     variable->updateValue();
             }
         }
     }
     else
     {
         activePopup_ = new QMenu(this);
         QMenu format(this);
 
         QAction* remember = 0;
         QAction* remove = 0;
         QAction* reevaluate = 0;
         QAction* watch = 0;
 
         QAction* natural = 0;
         QAction* hex = 0;
         QAction* decimal = 0;
         QAction* character = 0;
         QAction* binary = 0;
 
 #define MAYBE_DISABLE(action) if (!var->isAlive()) action->setEnabled(false)
 
         VariableItem* var = qobject_cast<VariableItem*>(item);
 
         AbstractVariableItem* root = item->abstractRoot();
 
         RecentItem* recentRoot = qobject_cast<RecentItem*>(root);
 
         if (!recentRoot)
         {
             remember = activePopup_->addAction(QIcon::fromTheme("draw-freehand"), i18n("Remember Value"));
             MAYBE_DISABLE(remember);
         }
 
         if (!recentRoot) {
             watch = activePopup_->addAction(i18n("Watch Variable"));
             MAYBE_DISABLE(watch);
         }
 
         if (recentRoot) {
             reevaluate = activePopup_->addAction(QIcon::fromTheme("reload"), i18n("Reevaluate Expression"));
             MAYBE_DISABLE(reevaluate);
             remove = activePopup_->addAction(QIcon::fromTheme("editdelete"), i18n("Remove Expression"));
             remove->setShortcut(Qt::Key_Delete);
         }
 
         if (var)
         {
             toggleWatch_ = activePopup_->addAction( i18n("Data write breakpoint") );
             toggleWatch_->setCheckable(true);
             toggleWatch_->setEnabled(false);
         }
 
         /* This code can be executed when debugger is stopped,
            and we invoke popup menu on a var under "recent expressions"
            just to delete it. */
         if (var && var->isAlive() && !controller()->stateIsOn(s_dbgNotStarted)) {
             GDBCommand* cmd =  new GDBCommand(DataEvaluateExpression,
                                                 QStringLiteral("&%1")
                                                 .arg(var->gdbExpression()));
             cmd->setHandler(this, &VariableTree::handleAddressComputed, true /*handles error*/);
             cmd->setThread(var->thread());
             cmd->setFrame(var->frame());
             controller_->addCommand(cmd);
         }
 
 
         QAction* res = activePopup_->exec(event->globalPos());
         delete activePopup_;
         activePopup_ = 0;
 
         if (res == remember)
         {
             if (var)
             {
                 ((VariableWidget*)parent())->
                     slotEvaluateExpression(var->gdbExpression());
             }
         }
         else if (res == watch)
         {
             if (var)
             {
                 ((VariableWidget*)parent())->
                     slotAddWatchVariable(var->gdbExpression());
             }
         }
         else if (res == remove)
         {
             delete item;
         }
         else if (res == toggleWatch_)
         {
             if (var)
                 emit toggleWatchpoint(var->gdbExpression());
         }
         else if (res == reevaluate)
         {
             if (var)
             {
                 var->updateValue();
             }
         }
 
         event->accept();
     }
 }
 
 
 void VariableTree::updateCurrentFrame()
 {
 }
 
 // **************************************************************************
 
 void VariableTree::handleAddressComputed(const GDBMI::ResultRecord& r)
 {
     if (r.reason == "error")
     {
         // Not lvalue, leave item disabled.
         return;
     }
 
     if (activePopup_)
     {
         toggleWatch_->setEnabled(true);
 
         //quint64 address = r["value"].literal().toULongLong(0, 16);
         /*if (breakpointWidget_->hasWatchpointForAddress(address))
         {
             toggleWatch_->setChecked(true);
         }*/
     }
 }
 
 VariableCollection * VariableTree::collection() const
 {
     return controller_->variables();
 }
 
 GDBController * VariableTree::controller() const
 {
     return controller_;
 }
 
 void VariableTree::showEvent(QShowEvent * event)
 {
     Q_UNUSED(event)
 
     for (int i = 0; i < model()->columnCount(); ++i)
         resizeColumnToContents(i);
 }
 #endif
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 }
 
diff --git a/language/backgroundparser/parsejob.cpp b/language/backgroundparser/parsejob.cpp
index 55b13163d..b38ae36c2 100644
--- a/language/backgroundparser/parsejob.cpp
+++ b/language/backgroundparser/parsejob.cpp
@@ -1,529 +1,521 @@
 /*
 * This file is part of KDevelop
 *
 * Copyright 2006 Adam Treat <treat@kde.org>
 * Copyright 2006-2008 Hamish Rodda <rodda@kde.org>
 *
 * This program 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 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 "parsejob.h"
 
 #include <QFile>
 #include <QByteArray>
 #include <QMutex>
 #include <QMutexLocker>
-#include <threadweaver/qobjectdecorator.h>
 #include <QApplication>
 #include <QDebug>
 
 #include <KLocalizedString>
 #include <KFormat>
 #include <ktexteditor/movinginterface.h>
 
 #include "backgroundparser.h"
 #include "util/debug.h"
 #include "duchain/topducontext.h"
 
 #include "duchain/duchainlock.h"
 #include "duchain/duchain.h"
 #include "duchain/parsingenvironment.h"
 
 #include <util/foregroundlock.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <codegen/coderepresentation.h>
 #include <duchain/declaration.h>
 #include <duchain/use.h>
 #include <interfaces/icodehighlighting.h>
 #include <duchain/problem.h>
 
 
 using namespace KTextEditor;
 
 static QMutex minimumFeaturesMutex;
 static QHash<KDevelop::IndexedString, QList<KDevelop::TopDUContext::Features> > staticMinimumFeatures;
 
 namespace KDevelop
 {
 
 class ParseJobPrivate
 {
 public:
 
     ParseJobPrivate(const IndexedString& url_, ILanguageSupport* languageSupport_) :
           url( url_ )
         , languageSupport( languageSupport_ )
         , abortRequested( 0 )
         , hasReadContents( false )
         , aborted( false )
         , features( TopDUContext::VisibleDeclarationsAndContexts )
         , parsePriority( 0 )
         , sequentialProcessingFlags( ParseJob::IgnoresSequentialProcessing )
     {
     }
 
     ~ParseJobPrivate()
     {
     }
 
     ReferencedTopDUContext duContext;
 
     IndexedString url;
     ILanguageSupport* languageSupport;
 
     ParseJob::Contents contents;
 
     QAtomicInt abortRequested;
 
     bool hasReadContents : 1;
     bool aborted : 1;
     TopDUContext::Features features;
     QList<QPointer<QObject> > notify;
     QPointer<DocumentChangeTracker> tracker;
     RevisionReference revision;
     RevisionReference previousRevision;
 
     int parsePriority;
     ParseJob::SequentialProcessingFlags sequentialProcessingFlags;
-    ThreadWeaver::QObjectDecorator* decorator;
 };
 
 ParseJob::ParseJob( const IndexedString& url, KDevelop::ILanguageSupport* languageSupport )
         : ThreadWeaver::Sequence(),
         d(new ParseJobPrivate(url, languageSupport))
 {
-    d->decorator = new ThreadWeaver::QObjectDecorator(this);
 }
 
 ParseJob::~ParseJob()
 {
     typedef QPointer<QObject> QObjectPointer;
     foreach(const QObjectPointer &p, d->notify) {
         if(p) {
             QMetaObject::invokeMethod(p.data(), "updateReady", Qt::QueuedConnection, Q_ARG(KDevelop::IndexedString, d->url), Q_ARG(KDevelop::ReferencedTopDUContext, d->duContext));
         }
     }
 
     delete d;
 }
 
 ILanguageSupport* ParseJob::languageSupport() const
 {
     return d->languageSupport;
 }
 
 void ParseJob::setParsePriority(int priority)
 {
     d->parsePriority = priority;
 }
 
 int ParseJob::parsePriority() const
 {
     return d->parsePriority;
 }
 
 bool ParseJob::requiresSequentialProcessing() const
 {
     return d->sequentialProcessingFlags & RequiresSequentialProcessing;
 }
 
 bool ParseJob::respectsSequentialProcessing() const
 {
     return d->sequentialProcessingFlags & RespectsSequentialProcessing;
 }
 
 void ParseJob::setSequentialProcessingFlags(SequentialProcessingFlags flags)
 {
     d->sequentialProcessingFlags = flags;
 }
 
 IndexedString ParseJob::document() const
 {
     return d->url;
 }
 
 bool ParseJob::success() const
 {
     return !d->aborted;
 }
 
 void ParseJob::setMinimumFeatures(TopDUContext::Features features)
 {
     d->features = features;
 }
 
 bool ParseJob::hasStaticMinimumFeatures()
 {
     QMutexLocker lock(&minimumFeaturesMutex);
     return ::staticMinimumFeatures.size();
 }
 
 TopDUContext::Features ParseJob::staticMinimumFeatures(const IndexedString& url)
 {
     QMutexLocker lock(&minimumFeaturesMutex);
     TopDUContext::Features features = (TopDUContext::Features)0;
 
     if(::staticMinimumFeatures.contains(url))
         foreach(const TopDUContext::Features &f, ::staticMinimumFeatures[url])
             features = (TopDUContext::Features)(features | f);
 
     return features;
 }
 
 TopDUContext::Features ParseJob::minimumFeatures() const
 {
     return (TopDUContext::Features)(d->features | staticMinimumFeatures(d->url));
 }
 
 void ParseJob::setDuChain(ReferencedTopDUContext duChain)
 {
     d->duContext = duChain;
 }
 
 ReferencedTopDUContext ParseJob::duChain() const
 {
     return d->duContext;
 }
 
 bool ParseJob::abortRequested() const
 {
     return d->abortRequested.load();
 }
 
 void ParseJob::requestAbort()
 {
     d->abortRequested = 1;
 }
 
 void ParseJob::abortJob()
 {
     d->aborted = true;
     setStatus(Status_Aborted);
 }
 
 void ParseJob::setNotifyWhenReady(const QList<QPointer< QObject > >& notify
 ) {
     d->notify = notify;
 }
 
 void ParseJob::setStaticMinimumFeatures(const IndexedString& url, TopDUContext::Features features) {
     QMutexLocker lock(&minimumFeaturesMutex);
     ::staticMinimumFeatures[url].append(features);
 }
 
 void ParseJob::unsetStaticMinimumFeatures(const IndexedString& url, TopDUContext::Features features) {
     QMutexLocker lock(&minimumFeaturesMutex);
     ::staticMinimumFeatures[url].removeOne(features);
     if(::staticMinimumFeatures[url].isEmpty())
       ::staticMinimumFeatures.remove(url);
 }
 
 KDevelop::ProblemPointer ParseJob::readContents()
 {
     Q_ASSERT(!d->hasReadContents);
     d->hasReadContents = true;
 
     QString localFile(document().toUrl().toLocalFile());
     QFileInfo fileInfo( localFile );
 
     QDateTime lastModified = fileInfo.lastModified();
 
     d->tracker = ICore::self()->languageController()->backgroundParser()->trackerForUrl(document());
 
     //Try using an artificial code-representation, which overrides everything else
     if(artificialCodeRepresentationExists(document())) {
         CodeRepresentation::Ptr repr = createCodeRepresentation(document());
         d->contents.contents = repr->text().toUtf8();
         qCDebug(LANGUAGE) << "took contents for " << document().str() << " from artificial code-representation";
         return KDevelop::ProblemPointer();
     }
 
     bool hadTracker = false;
     if(d->tracker)
     {
         ForegroundLock lock;
         if(DocumentChangeTracker* t = d->tracker.data())
         {
             // The file is open in an editor
             d->previousRevision = t->revisionAtLastReset();
 
             t->reset(); // Reset the tracker to the current revision
             Q_ASSERT(t->revisionAtLastReset());
 
             d->contents.contents = t->document()->text().toUtf8();
             d->contents.modification = KDevelop::ModificationRevision( lastModified, t->revisionAtLastReset()->revision() );
 
             d->revision = t->acquireRevision(d->contents.modification.revision);
             hadTracker = true;
         }
     }
     if (!hadTracker) {
         // We have to load the file from disk
 
         static const int maximumFileSize = 5 * 1024 * 1024; // 5 MB
         if (fileInfo.size() > maximumFileSize) {
             KFormat f;
 
             KDevelop::ProblemPointer p(new Problem());
             p->setSource(IProblem::Disk);
             p->setDescription(i18nc("%1: filename", "Skipped file that is too large: '%1'", localFile ));
             p->setExplanation(i18nc("%1: file size, %2: limit file size",
                                     "The file is %1 and exceeds the limit of %2.",
                                     f.formatByteSize(fileInfo.size()),
                                     f.formatByteSize(maximumFileSize)));
             p->setFinalLocation(DocumentRange(document(), KTextEditor::Range::invalid()));
             qCWarning(LANGUAGE) << p->description() << p->explanation();
             return p;
         }
         QFile file( localFile );
 
         if ( !file.open( QIODevice::ReadOnly ) )
         {
             KDevelop::ProblemPointer p(new Problem());
             p->setSource(IProblem::Disk);
             p->setDescription(i18n( "Could not open file '%1'", localFile ));
             switch (file.error()) {
               case QFile::ReadError:
                   p->setExplanation(i18n("File could not be read from disk."));
                   break;
               case QFile::OpenError:
                   p->setExplanation(i18n("File could not be opened."));
                   break;
               case QFile::PermissionsError:
                   p->setExplanation(i18n("File could not be read from disk due to permissions."));
                   break;
               default:
                   break;
             }
             p->setFinalLocation(DocumentRange(document(), KTextEditor::Range::invalid()));
 
             qCWarning(LANGUAGE) << "Could not open file" << document().str() << "(path" << localFile << ")" ;
 
             return p;
         }
 
         d->contents.contents = file.readAll(); ///@todo Convert from local encoding to utf-8 if they don't match
         d->contents.modification = KDevelop::ModificationRevision(lastModified);
 
         file.close();
     }
 
     return KDevelop::ProblemPointer();
 }
 
 const KDevelop::ParseJob::Contents& ParseJob::contents() const
 {
     Q_ASSERT(d->hasReadContents);
     return d->contents;
 }
 
 struct MovingRangeTranslator : public DUChainVisitor
 {
     MovingRangeTranslator(qint64 _source, qint64 _target, MovingInterface* _moving) : source(_source), target(_target), moving(_moving) {
     }
 
     void visit(DUContext* context) override {
         translateRange(context);
         ///@todo Also map import-positions
         // Translate uses
         uint usesCount = context->usesCount();
         for(uint u = 0; u < usesCount; ++u)
         {
             RangeInRevision r = context->uses()[u].m_range;
             translateRange(r);
             context->changeUseRange(u, r);
         }
     }
 
     void visit(Declaration* declaration) override {
         translateRange(declaration);
     }
 
     void translateRange(DUChainBase* object)
     {
         RangeInRevision r = object->range();
         translateRange(r);
         object->setRange(r);
     }
 
     void translateRange(RangeInRevision& r)
     {
         // PHP and python use top contexts that start at (0, 0) end at INT_MAX, so make sure that doesn't overflow
         // or translate the start of the top context away from (0, 0)
         if ( r.start.line != 0 || r.start.column != 0 ) {
             moving->transformCursor(r.start.line, r.start.column, MovingCursor::MoveOnInsert, source, target);
         }
         if ( r.end.line != std::numeric_limits<int>::max() || r.end.column != std::numeric_limits<int>::max() ) {
             moving->transformCursor(r.end.line, r.end.column, MovingCursor::StayOnInsert, source, target);
         }
     }
 
     KTextEditor::Range range;
     qint64 source;
     qint64 target;
     MovingInterface* moving;
 };
 
 void ParseJob::translateDUChainToRevision(TopDUContext* context)
 {
     qint64 targetRevision = d->contents.modification.revision;
 
     if(targetRevision == -1)
     {
         qCDebug(LANGUAGE) << "invalid target revision" << targetRevision;
         return;
     }
 
     qint64 sourceRevision;
 
     {
         DUChainReadLocker duChainLock;
 
         Q_ASSERT(context->parsingEnvironmentFile());
 
         // Cannot map if there is no source revision
         sourceRevision = context->parsingEnvironmentFile()->modificationRevision().revision;
 
         if(sourceRevision == -1)
         {
             qCDebug(LANGUAGE) << "invalid source revision" << sourceRevision;
             return;
         }
     }
 
     if(sourceRevision > targetRevision)
     {
         qCDebug(LANGUAGE) << "for document" << document().str() << ": source revision is higher than target revision:" << sourceRevision << " > " << targetRevision;
         return;
     }
 
     ForegroundLock lock;
     if(DocumentChangeTracker* t = d->tracker.data())
     {
         if(!d->previousRevision)
         {
             qCDebug(LANGUAGE) << "not translating because there is no valid predecessor-revision";
             return;
         }
 
         if(sourceRevision != d->previousRevision->revision() || !d->previousRevision->valid())
         {
             qCDebug(LANGUAGE) << "not translating because the document revision does not match the tracker start revision (maybe the document was cleared)";
             return;
         }
 
         if(!t->holdingRevision(sourceRevision) || !t->holdingRevision(targetRevision))
         {
             qCDebug(LANGUAGE) << "lost one of the translation revisions, not doing the map";
             return;
         }
 
         // Perform translation
         MovingInterface* moving = t->documentMovingInterface();
 
         DUChainWriteLocker wLock;
 
         MovingRangeTranslator translator(sourceRevision, targetRevision, moving);
         context->visit(translator);
 
         QList< ProblemPointer > problems = context->problems();
         for(QList< ProblemPointer >::iterator problem = problems.begin(); problem != problems.end(); ++problem)
         {
             RangeInRevision r = (*problem)->range();
             translator.translateRange(r);
             (*problem)->setRange(r);
         }
 
         // Update the modification revision in the meta-data
         ModificationRevision modRev = context->parsingEnvironmentFile()->modificationRevision();
         modRev.revision = targetRevision;
         context->parsingEnvironmentFile()->setModificationRevision(modRev);
     }
 }
 
 bool ParseJob::isUpdateRequired(const IndexedString& languageString)
 {
     if (abortRequested()) {
         return false;
     }
 
     if (minimumFeatures() & TopDUContext::ForceUpdate) {
         return true;
     }
 
     DUChainReadLocker lock;
     if (abortRequested()) {
         return false;
     }
     foreach(const ParsingEnvironmentFilePointer &file, DUChain::self()->allEnvironmentFiles(document())) {
         if (file->language() != languageString) {
             continue;
         }
         if (!file->needsUpdate(environment()) && file->featuresSatisfied(minimumFeatures())) {
             qCDebug(LANGUAGE) << "Already up to date" << document().str();
             setDuChain(file->topContext());
             lock.unlock();
             highlightDUChain();
             return false;
         }
         break;
     }
     return !abortRequested();
 }
 
 const ParsingEnvironment* ParseJob::environment() const
 {
     return nullptr;
 }
 
 void ParseJob::highlightDUChain()
 {
     ENSURE_CHAIN_NOT_LOCKED
     if (!d->languageSupport->codeHighlighting() || !duChain() || abortRequested()) {
         // language doesn't support highlighting
         return;
     }
     if (!d->hasReadContents && !d->tracker) {
         d->tracker = ICore::self()->languageController()->backgroundParser()->trackerForUrl(document());
     }
     if (d->tracker) {
         d->languageSupport->codeHighlighting()->highlightDUChain(duChain());
     }
 }
 
 ControlFlowGraph* ParseJob::controlFlowGraph()
 {
     return nullptr;
 }
 
 DataAccessRepository* ParseJob::dataAccessInformation()
 {
     return nullptr;
 }
 
 bool ParseJob::hasTracker() const
 {
     return d->tracker;
 }
 
-ThreadWeaver::QObjectDecorator* ParseJob::decorator() const
-{
-    return d->decorator;
-}
-
 }
 
diff --git a/language/backgroundparser/parsejob.h b/language/backgroundparser/parsejob.h
index f79b41c22..a08e6ba85 100644
--- a/language/backgroundparser/parsejob.h
+++ b/language/backgroundparser/parsejob.h
@@ -1,243 +1,241 @@
 /*
 * This file is part of KDevelop
 *
 * Copyright 2006 Adam Treat <treat@kde.org>
 * Copyright 2006-2008 Hamish Rodda <rodda@kde.org>
 *
 * This program 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 program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_PARSEJOB_H
 #define KDEVPLATFORM_PARSEJOB_H
 
 #include <QPointer>
 
 #include <ThreadWeaver/Sequence>
 
 #include <serialization/indexedstring.h>
 #include <language/duchain/topducontext.h>
 #include <language/editor/modificationrevision.h>
 
 namespace ThreadWeaver {
 class QObjectDecorator;
 }
 
 namespace KDevelop
 {
 
 class ParsingEnvironment;
 class ControlFlowGraph;
 class DataAccessRepository;
 class BackgroundParser;
 class TopDUContext;
 class ReferencedTopDUContext;
 
 /**
  * The base class for background parser jobs.
  *
  * In your language plugin, don't forget to use acquire an UrlParseLock before starting to the actual parsing.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT ParseJob : public QObject, public ThreadWeaver::Sequence
 {
     Q_OBJECT
 
 public:
     explicit ParseJob( const IndexedString &url, ILanguageSupport* languageSupport );
     /**
      * _No_ mutexes/locks are allowed to be locked when this object is destroyed (except for optionally the foreground lock)
      * */
     ~ParseJob() override;
 
     /**
      * @return the language support that created this parse job.
      */
     ILanguageSupport* languageSupport() const;
 
     struct Contents {
         // Modification-time of the read content
         ModificationRevision modification;
         // The contents in utf-8 format
         QByteArray contents;
     };
 
     enum SequentialProcessingFlag {
         IgnoresSequentialProcessing = 0,
         RequiresSequentialProcessing = 1,
         RespectsSequentialProcessing = 2,
         FullSequentialProcessing = 3
     };
     Q_DECLARE_FLAGS(SequentialProcessingFlags, SequentialProcessingFlag)
 
     ///Sets the priority of this parse job. This is just for the purpose of
     ///reading it later, and does not affect the actual behaviour in any way.
     void setParsePriority(int priority);
     ///Get the priority of this parse job.
     ///Other than priority(), this will give you the "KDevelop-priority" of the job,
     ///not the QThread one (which is always zero).
     int parsePriority() const;
 
     /**
      * _No_ mutexes/locks are allowed to be locked when this is called (except for optionally the foreground lock)
      *
      * Locks the document revision so that mapping from/to the revision in the editor using MovingInterface will be possible.
      *
      * Returns an invalid pointer if the call succeeds, and a valid one if the reading fails.
      * */
     KDevelop::ProblemPointer readContents();
 
     /**
      * After reading the contents, you can call this to retrieve it.
      * */
     const Contents& contents() const;
 
     /**
      * Translates the given context from its previous revision to the revision that has
      * been retrieved during readContents(). The top-context meta-data will be updated
      * with the revision.
      *
      * This can be done after reading the context before updating, so
      * that the correct ranges are matched onto each other during the update.
      *
      * _No_ mutexes/locks are allowed to be locked when this is called (except for optionally the foreground lock)
      */
     void translateDUChainToRevision(TopDUContext* context);
 
     /**
      * Query whether this job is needed to be waited for when trying to process a job with a lower priority.
      **/
     bool respectsSequentialProcessing() const;
 
     /**
      * Query whether this job requires all higher-priority jobs to finish before being processed itself.
      **/
     bool requiresSequentialProcessing() const;
 
     void setSequentialProcessingFlags(SequentialProcessingFlags flags);
 
     /// \returns the indexed url of the document to be parsed.
     Q_SCRIPTABLE KDevelop::IndexedString document() const;
 
     /**
     * Sets a list of QObjects that should contain a slot
     * "void updateReady(KDevelop::IndexedString url, KDevelop::ReferencedTopDUContext topContext)".
     * The notification is guaranteed to be called once the parse-job finishes, from within its destructor.
     * The given top-context may be invalid if the update failed.
     */
     Q_SCRIPTABLE void setNotifyWhenReady(const QList<QPointer<QObject> >& notify);
 
     /// Sets the du-context that was created by this parse-job
     Q_SCRIPTABLE virtual void setDuChain(ReferencedTopDUContext duChain);
     /// Returns the set du-context, or zero of none was set.
     Q_SCRIPTABLE virtual ReferencedTopDUContext duChain() const;
 
     /// Overridden to allow jobs to determine if they've been requested to abort
     Q_SCRIPTABLE void requestAbort() override;
     /// Determine if the job has been requested to abort
     Q_SCRIPTABLE bool abortRequested() const;
     /// Sets success to false, causing failed() to be emitted
     Q_SCRIPTABLE void abortJob();
 
     /// Overridden to convey whether the job succeeded or not.
     Q_SCRIPTABLE bool success() const override;
 
     /// Set the minimum features the resulting top-context should have
     Q_SCRIPTABLE void setMinimumFeatures(TopDUContext::Features features);
 
     /// Minimum set of features the resulting top-context should have
     Q_SCRIPTABLE TopDUContext::Features minimumFeatures() const;
 
     /// Allows statically specifying an amount of features required for an url.
     /// These features will automatically be or'ed with the minimumFeatures() returned
     /// by any ParseJob with the given url.
     /// Since this causes some additional complixity in update-checking, minimum features should not
     /// be set permanently.
     static void setStaticMinimumFeatures(const IndexedString& url, TopDUContext::Features features);
 
     /// Must be called exactly once for each call to setStaticMinimumFeatures, with the same features.
     static void unsetStaticMinimumFeatures(const IndexedString& url, TopDUContext::Features features);
 
     /// Returns the statically set minimum features for  the given url, or zero.
     static TopDUContext::Features staticMinimumFeatures(const IndexedString& url);
 
     /// Returns whether there is minimum features set up for some url
     static bool hasStaticMinimumFeatures();
 
     ///Returns a structure containing information about data accesses in the parsed file.
     /// It's up to the caller to remove the returned instance
     virtual KDevelop::DataAccessRepository* dataAccessInformation();
 
     ///Returns a control flow graph for the code in the parsed file.
     /// It's up to the caller to remove the returned instance
     virtual KDevelop::ControlFlowGraph* controlFlowGraph();
 
-    ThreadWeaver::QObjectDecorator* decorator() const;
-
 Q_SIGNALS:
     /**Can be used to give progress feedback to the background-parser. @param value should be between 0 and 1, where 0 = 0% and 1 = 100%
      * @param text may be a text that describes the current state of parsing
      * Do not trigger this too often, for performance reasons. */
     void progress(KDevelop::ParseJob*, float value, const QString& text);
 
 protected:
     /**
      * Should return an environment for this parse job.
      *
      * This is then used to check whether existing cached data of previous parse jobs need an update.
      * The default implementation returns a nullptr.
      */
     virtual const ParsingEnvironment* environment() const;
 
     /**
      * Checks whether there is already an up to date context available for the
      * current document. If so, it returns true and ensures that the document
      * is highlighted properly. Otherwise returns false.
      *
      * NOTE: This should be called while holding an URLParseLock for the
      * current document.
      *
      * @param languageString The unique string identifying your language.
      * This must be the same as you assign to the DUChain's environment file.
      *
      * @return True if an update is required, false if the job can return early.
      */
     bool isUpdateRequired(const IndexedString& languageString);
 
     /**
      * Trigger an update to the code highlighting of the current file based
      * on the DUChain set in setDuChain.
      *
      * If the file for this parse job is not opened in an editor or if the language
      * support does not return a code highlighter, this will do nothing.
      *
      * NOTE: No DUChain lock should be held when you call this.
      */
     void highlightDUChain();
 
     /**
      * Returns whether there is a tracker for the current document.
      */
     bool hasTracker() const;
 
 private:
     class ParseJobPrivate* const d;
 };
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KDevelop::ParseJob::SequentialProcessingFlags)
 Q_DECLARE_METATYPE(KDevelop::ParseJob*)
 
 #endif
diff --git a/language/codegen/sourcefiletemplate.cpp b/language/codegen/sourcefiletemplate.cpp
index 5f15e0a2d..1707d5571 100644
--- a/language/codegen/sourcefiletemplate.cpp
+++ b/language/codegen/sourcefiletemplate.cpp
@@ -1,319 +1,319 @@
 /*
  * This file is part of KDevelop
  * Copyright 2012 Miha Čančula <miha@noughmad.eu>
  *
  * 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 "sourcefiletemplate.h"
 #include "templaterenderer.h"
 #include "util/debug.h"
 
 #include <interfaces/icore.h>
 
 #include <KArchive>
 #include <KConfig>
 #include <KZip>
 #include <KTar>
 #include <KConfigGroup>
 
 #include <QFileInfo>
 #include <QDomDocument>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDebug>
 
 using namespace KDevelop;
 typedef SourceFileTemplate::ConfigOption ConfigOption;
 
 class KDevelop::SourceFileTemplatePrivate
 {
 public:
     KArchive* archive;
     QString descriptionFileName;
     QStringList searchLocations;
 
     ConfigOption readEntry(const QDomElement& element, TemplateRenderer* renderer);
 };
 
 ConfigOption SourceFileTemplatePrivate::readEntry(const QDomElement& element,
                                                   TemplateRenderer* renderer)
 {
     ConfigOption entry;
 
     entry.name = element.attribute("name");
     entry.type = element.attribute("type", "String");
 
     for (QDomElement e = element.firstChildElement(); !e.isNull(); e = e.nextSiblingElement())
     {
         QString tag = e.tagName();
 
         if (tag == "label")
         {
             entry.label = e.text();
         }
         else if (tag == "tooltip")
         {
             entry.label = e.text();
         }
         else if (tag == "whatsthis")
         {
             entry.label = e.text();
         }
         else if ( tag == "min" )
         {
             entry.minValue = e.text();
         }
         else if ( tag == "max" )
         {
             entry.maxValue = e.text();
         }
         else if ( tag == "default" )
         {
             entry.value = renderer->render(e.text(), entry.name);
         }
     }
 
     qCDebug(LANGUAGE) << "Read entry" << entry.name << "with default value" << entry.value;
     return entry;
 }
 
 
 SourceFileTemplate::SourceFileTemplate (const QString& templateDescription)
 : d(new KDevelop::SourceFileTemplatePrivate)
 {
     d->archive = 0;
     setTemplateDescription(templateDescription);
 }
 
 SourceFileTemplate::SourceFileTemplate()
 : d(new KDevelop::SourceFileTemplatePrivate)
 {
     d->archive = 0;
 }
 
 SourceFileTemplate::SourceFileTemplate (const SourceFileTemplate& other)
 : d(new KDevelop::SourceFileTemplatePrivate)
 {
     d->archive = 0;
     *this = other;
 }
 
 SourceFileTemplate::~SourceFileTemplate()
 {
     delete d->archive;
     delete d;
 }
 
 SourceFileTemplate& SourceFileTemplate::operator=(const SourceFileTemplate& other)
 {
     if (other.d == d) {
         return *this;
     }
 
     delete d->archive;
     if (other.d->archive) {
         if (other.d->archive->fileName().endsWith(".zip")) {
             d->archive = new KZip(other.d->archive->fileName());
         } else {
             d->archive = new KTar(other.d->archive->fileName());
         }
         d->archive->open(QIODevice::ReadOnly);
     } else {
         d->archive = 0;
     }
     d->descriptionFileName = other.d->descriptionFileName;
     return *this;
 }
 
 void SourceFileTemplate::setTemplateDescription(const QString& templateDescription)
 {
     delete d->archive;
 
     d->descriptionFileName = templateDescription;
     QString archiveFileName;
 
     const QString templateBaseName = QFileInfo(templateDescription).baseName();
 
     d->searchLocations.append(QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, "/kdevfiletemplates/templates/", QStandardPaths::LocateDirectory));
 
     foreach(const QString& dir, d->searchLocations) {
         qDebug() << "search in:" << dir << "look for:" << templateBaseName;
         foreach(const auto& entry, QDir(dir).entryInfoList(QDir::Files)) {
             qDebug() << entry.baseName();
             if (entry.baseName() == templateBaseName) {
                 archiveFileName = entry.absoluteFilePath();
                 qCDebug(LANGUAGE) << "Found template archive" << archiveFileName;
                 break;
             }
         }
     }
 
     if (archiveFileName.isEmpty() || !QFileInfo(archiveFileName).exists()) {
         qCWarning(LANGUAGE) << "Could not find a template archive for description" << templateDescription << ", archive file" << archiveFileName;
         d->archive = 0;
     } else {
         QFileInfo info(archiveFileName);
 
-        if (info.suffix() == ".zip") {
+        if (info.suffix() == "zip") {
             d->archive = new KZip(archiveFileName);
         } else {
             d->archive = new KTar(archiveFileName);
         }
         d->archive->open(QIODevice::ReadOnly);
     }
 }
 
 bool SourceFileTemplate::isValid() const
 {
     return d->archive;
 }
 
 QString SourceFileTemplate::name() const
 {
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     return cg.readEntry("Name");
 }
 
 QString SourceFileTemplate::type() const
 {
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     return cg.readEntry("Type", QString());
 }
 
 QString SourceFileTemplate::languageName() const
 {
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     return cg.readEntry("Language", QString());
 }
 
 QStringList SourceFileTemplate::category() const
 {
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     return cg.readEntry("Category", QStringList());
 }
 
 QStringList SourceFileTemplate::defaultBaseClasses() const
 {
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     return cg.readEntry("BaseClasses", QStringList());
 }
 
 const KArchiveDirectory* SourceFileTemplate::directory() const
 {
     Q_ASSERT(isValid());
     return d->archive->directory();
 }
 
 QList< SourceFileTemplate::OutputFile > SourceFileTemplate::outputFiles() const
 {
     QList<SourceFileTemplate::OutputFile> outputFiles;
 
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup group(&templateConfig, "General");
 
     QStringList files = group.readEntry("Files", QStringList());
     qCDebug(LANGUAGE) << "Files in template" << files;
     foreach (const QString& fileGroup, files)
     {
         KConfigGroup cg(&templateConfig, fileGroup);
         OutputFile f;
         f.identifier = cg.name();
         f.label = cg.readEntry("Name");
         f.fileName = cg.readEntry("File");
         f.outputName = cg.readEntry("OutputFile");
         outputFiles << f;
     }
 
     return outputFiles;
 }
 
 bool SourceFileTemplate::hasCustomOptions() const
 {
     Q_ASSERT(isValid());
 
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     bool hasOptions = d->archive->directory()->entries().contains(cg.readEntry("OptionsFile", "options.kcfg"));
 
     qCDebug(LANGUAGE) << cg.readEntry("OptionsFile", "options.kcfg") << hasOptions;
     return hasOptions;
 }
 
 QHash< QString, QList<ConfigOption> > SourceFileTemplate::customOptions(TemplateRenderer* renderer) const
 {
     Q_ASSERT(isValid());
 
     KConfig templateConfig(d->descriptionFileName);
     KConfigGroup cg(&templateConfig, "General");
     const KArchiveEntry* entry = d->archive->directory()->entry(cg.readEntry("OptionsFile", "options.kcfg"));
 
     QHash<QString, QList<ConfigOption> > options;
 
     if (!entry->isFile())
     {
         return options;
     }
     const KArchiveFile* file = static_cast<const KArchiveFile*>(entry);
 
     /*
      * Copied from kconfig_compiler.kcfg
      */
     QDomDocument doc;
     QString errorMsg;
     int errorRow;
     int errorCol;
     if ( !doc.setContent( file->data(), &errorMsg, &errorRow, &errorCol ) ) {
         qCDebug(LANGUAGE) << "Unable to load document.";
         qCDebug(LANGUAGE) << "Parse error in line " << errorRow << ", col " << errorCol << ": " << errorMsg;
         return options;
     }
 
     QDomElement cfgElement = doc.documentElement();
     if ( cfgElement.isNull() ) {
         qCDebug(LANGUAGE) << "No document in kcfg file";
         return options;
     }
 
     QDomNodeList groups = cfgElement.elementsByTagName("group");
     for (int i = 0; i < groups.size(); ++i)
     {
         QDomElement group = groups.at(i).toElement();
         QList<ConfigOption> optionGroup;
         QString groupName = group.attribute("name");
 
         QDomNodeList entries = group.elementsByTagName("entry");
         for (int j = 0; j < entries.size(); ++j)
         {
             QDomElement entry = entries.at(j).toElement();
             optionGroup << d->readEntry(entry, renderer);
         }
 
         options.insert(groupName, optionGroup);
     }
     return options;
 }
 
 void SourceFileTemplate::addAdditionalSearchLocation(const QString& location)
 {
     if(!d->searchLocations.contains(location))
         d->searchLocations.append(location);
 }
diff --git a/outputview/outputjob.cpp b/outputview/outputjob.cpp
index 410a2ee48..6a6d1d696 100644
--- a/outputview/outputjob.cpp
+++ b/outputview/outputjob.cpp
@@ -1,175 +1,183 @@
 /* This file is part of KDevelop
 Copyright 2007-2008 Hamish Rodda <rodda@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 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 "outputjob.h"
 
 #include <QStandardItemModel>
 #include <QItemDelegate>
 
 #include "interfaces/icore.h"
 #include "interfaces/iplugincontroller.h"
 #include "outputview/ioutputview.h"
 
 using namespace KDevelop;
 
 OutputJob::OutputJob(QObject* parent, OutputJobVerbosity verbosity)
     : KJob(parent)
     , m_standardToolView(-1)
     , m_type(IOutputView::OneView)
     , m_behaviours(IOutputView::AllowUserClose)
     , m_killJobOnOutputClose(true)
     , m_verbosity(verbosity)
     , m_outputId(-1)
     , m_outputDelegate(0)
 {
 }
 
 void OutputJob::startOutput()
 {
     IPlugin* i = ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IOutputView"));
     if( i )
     {
         KDevelop::IOutputView* view = i->extension<KDevelop::IOutputView>();
         if( view )
         {
             int tvid;
             if (m_standardToolView != -1) {
                 tvid = view->standardToolView( static_cast<IOutputView::StandardToolView>(m_standardToolView) );
             } else {
                 tvid = view->registerToolView(m_toolTitle, m_type, m_toolIcon);
             }
 
             if (m_title.isEmpty())
                 m_title = objectName();
 
             m_outputId = view->registerOutputInToolView( tvid, m_title, m_behaviours );
 
             if (!m_outputModel) {
                 m_outputModel = new QStandardItemModel(0);
             }
 
             // Keep the item model around after the job is gone
             view->setModel(m_outputId, m_outputModel);
 
             if (!m_outputDelegate) {
                 m_outputDelegate = new QItemDelegate(0);
             }
 
             view->setDelegate(m_outputId, m_outputDelegate);
 
             if (m_killJobOnOutputClose) {
                 // can't use qt5 signal slot syntax here, IOutputView is no a QObject
                 connect(i, SIGNAL(outputRemoved(int,int)), this, SLOT(outputViewRemoved(int,int)));
             }
 
             if (m_verbosity == OutputJob::Verbose)
                 view->raiseOutput(m_outputId);
         }
     }
 }
 
 void OutputJob::outputViewRemoved(int toolViewId, int id)
 {
     Q_UNUSED(toolViewId);
     if (id == m_outputId && m_killJobOnOutputClose)
     {
         // Make sure that the job emits result signal as the job
         // might be used in composite jobs and that one depends
         // on result being emitted to know whether a subjob
         // is done.
         kill( KJob::EmitResult );
     }
 }
 
 void KDevelop::OutputJob::setTitle(const QString & title)
 {
     m_title = title;
     if (m_outputId >= 0 && m_standardToolView >= 0) {
         IPlugin* i = ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IOutputView"));
         if( i )
         {
             KDevelop::IOutputView* view = i->extension<KDevelop::IOutputView>();
             if( view )
             {
                 view->setTitle(m_outputId, title);
             }
         }
     }
 }
 
 void KDevelop::OutputJob::setViewType(IOutputView::ViewType type)
 {
     m_type = type;
 }
 
 void KDevelop::OutputJob::setBehaviours(IOutputView::Behaviours behaviours)
 {
     m_behaviours = behaviours;
 }
 
 void KDevelop::OutputJob::setKillJobOnOutputClose(bool killJobOnOutputClose)
 {
     m_killJobOnOutputClose = killJobOnOutputClose;
 }
 
 void KDevelop::OutputJob::setModel(QAbstractItemModel * model)
 {
+    if (m_outputModel) {
+        delete m_outputModel;
+    }
+
     m_outputModel = model;
+
+    if (m_outputModel) {
+        m_outputModel->setParent(this);
+    }
 }
 
 void KDevelop::OutputJob::setDelegate(QAbstractItemDelegate * delegate)
 {
     m_outputDelegate = delegate;
 }
 
 QAbstractItemModel * KDevelop::OutputJob::model() const
 {
     return m_outputModel;
 }
 
 void KDevelop::OutputJob::setStandardToolView(IOutputView::StandardToolView standard)
 {
     m_standardToolView = standard;
 }
 
 void OutputJob::setToolTitle(const QString& title)
 {
     m_toolTitle = title;
 }
 
 void OutputJob::setToolIcon(const QIcon& icon)
 {
     m_toolIcon = icon;
 }
 
 int OutputJob::outputId() const
 {
     return m_outputId;
 }
 
 OutputJob::OutputJobVerbosity OutputJob::verbosity() const
 {
     return m_verbosity;
 }
 
 void OutputJob::setVerbosity(OutputJob::OutputJobVerbosity verbosity)
 {
     m_verbosity = verbosity;
 }
 
diff --git a/plugins/filetemplates/templatepreviewtoolview.cpp b/plugins/filetemplates/templatepreviewtoolview.cpp
index 08c500bcd..634d3f5fa 100644
--- a/plugins/filetemplates/templatepreviewtoolview.cpp
+++ b/plugins/filetemplates/templatepreviewtoolview.cpp
@@ -1,187 +1,181 @@
 /*
  * This file is part of KDevelop
  * Copyright 2012 Miha Čančula <miha@noughmad.eu>
  *
  * 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 "templatepreviewtoolview.h"
 
 #include "ui_templatepreviewtoolview.h"
 
 #include "filetemplatesplugin.h"
 #include "templatepreview.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <language/codegen/templaterenderer.h>
 
 #include <KTextEditor/Document>
 #include <KLocalizedString>
 
 #include <QLabel>
 #include <QVBoxLayout>
 
 using namespace KDevelop;
 
 TemplatePreviewToolView::TemplatePreviewToolView(FileTemplatesPlugin* plugin, QWidget* parent, Qt::WindowFlags f)
 : QWidget(parent, f)
 , ui(new Ui::TemplatePreviewToolView)
 , m_original(0)
 , m_plugin(plugin)
 {
     ui->setupUi(this);
     ui->messageWidget->hide();
     ui->emptyLinesPolicyComboBox->setCurrentIndex(1);
 
     IDocumentController* dc = ICore::self()->documentController();
     if (dc->activeDocument())
     {
         m_original = dc->activeDocument()->textDocument();
     }
 
     if (m_original)
     {
         documentActivated(dc->activeDocument());
     }
 
     connect(ui->projectRadioButton, &QRadioButton::toggled,
             this, &TemplatePreviewToolView::selectedRendererChanged);
     connect(ui->emptyLinesPolicyComboBox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
             this, &TemplatePreviewToolView::selectedRendererChanged);
     selectedRendererChanged();
 
     connect(dc, &IDocumentController::documentActivated,
             this, &TemplatePreviewToolView::documentActivated);
     connect(dc, &IDocumentController::documentClosed,
             this, &TemplatePreviewToolView::documentClosed);
 }
 
 TemplatePreviewToolView::~TemplatePreviewToolView()
 {
     delete ui;
 }
 
 void TemplatePreviewToolView::documentActivated(KDevelop::IDocument* document)
 {
-    if (!isVisible()) {
-        return;
-    }
-
     documentChanged(document->textDocument());
 }
 
 void TemplatePreviewToolView::documentChanged(KTextEditor::Document* document)
 {
     if (!isVisible()) {
         return;
     }
 
 
     if (m_original) {
         disconnect(m_original, &KTextEditor::Document::textChanged,
                    this, &TemplatePreviewToolView::documentChanged);
     }
     m_original = document;
 
     FileTemplatesPlugin::TemplateType type = FileTemplatesPlugin::NoTemplate;
     if (m_original) {
         connect(m_original, &KTextEditor::Document::textChanged,
                 this, &TemplatePreviewToolView::documentChanged);
         type = m_plugin->determineTemplateType(document->url());
     }
 
     switch (type) {
         case FileTemplatesPlugin::NoTemplate:
             ui->messageWidget->setMessageType(KMessageWidget::Information);
             if (m_original) {
                 ui->messageWidget->setText(xi18n("The active text document is not a <application>KDevelop</application> template"));
             } else {
                 ui->messageWidget->setText(i18n("No active text document."));
             }
             ui->messageWidget->animatedShow();
             ui->preview->setText(QString());
             break;
 
         case FileTemplatesPlugin::FileTemplate:
             ui->classRadioButton->setChecked(true);
             sourceTextChanged(m_original->text());
             break;
 
         case FileTemplatesPlugin::ProjectTemplate:
             ui->projectRadioButton->setChecked(true);
             sourceTextChanged(m_original->text());
             break;
     }
 }
 
 void TemplatePreviewToolView::showEvent(QShowEvent*)
 {
     IDocument* doc = ICore::self()->documentController()->activeDocument();
     documentChanged(doc ? doc->textDocument() : 0);
 }
 
 void TemplatePreviewToolView::documentClosed(IDocument* document)
 {
-    if (!isVisible()) {
-        return;
-    }
+    m_original = nullptr;
 
     if (document && document->textDocument() == m_original) {
-        documentChanged(0);
+        documentChanged(nullptr);
     }
 }
 
 void TemplatePreviewToolView::sourceTextChanged(const QString& text)
 {
     QString errorString = ui->preview->setText(text, ui->projectRadioButton->isChecked(), m_policy);
     if (!errorString.isEmpty()) {
         ui->messageWidget->setMessageType(KMessageWidget::Error);
         ui->messageWidget->setText(errorString);
         ui->messageWidget->animatedShow();
     } else {
         ui->messageWidget->animatedHide();
     }
 
     if (m_original) {
         ui->preview->document()->setMode(m_original->mode());
     }
 }
 
 void TemplatePreviewToolView::selectedRendererChanged()
 {
     if (ui->classRadioButton->isChecked())
     {
         TemplateRenderer::EmptyLinesPolicy policy = TemplateRenderer::KeepEmptyLines;
         switch (ui->emptyLinesPolicyComboBox->currentIndex())
         {
             case 0:
                 policy = TemplateRenderer::KeepEmptyLines;
                 break;
 
             case 1:
                 policy = TemplateRenderer::TrimEmptyLines;
                 break;
 
             case 2:
                 policy = TemplateRenderer::RemoveEmptyLines;
                 break;
         }
         m_policy = policy;
     }
     documentChanged(m_original);
 }
 
diff --git a/plugins/outlineview/outlinemodel.cpp b/plugins/outlineview/outlinemodel.cpp
index bccda5c09..786c08631 100644
--- a/plugins/outlineview/outlinemodel.cpp
+++ b/plugins/outlineview/outlinemodel.cpp
@@ -1,216 +1,225 @@
 /*
  *   KDevelop outline view
  *   Copyright 2010, 2015 Alex Richardson <alex.richardson@gmx.de>
  *
  *   This library is free software; you can redistribute it and/or
  *   modify it under the terms of the GNU Lesser General Public
  *   License as published by the Free Software Foundation; either
  *   version 2.1 of the License, or (at your option) any later version.
  *
  *   This library is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *   Lesser General Public License for more details.
  *
  *   You should have received a copy of the GNU Lesser General Public
  *   License along with this library; if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "outlinemodel.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 
 #include "debug_outline.h"
 #include "outlinenode.h"
 
 using namespace KDevelop;
 
 OutlineModel::OutlineModel(QObject* parent)
     : QAbstractItemModel(parent)
     , m_lastDoc(nullptr)
 {
     auto docController = ICore::self()->documentController();
     // build the initial outline now
     rebuildOutline(docController->activeDocument());
     // we must always have a valid root node
     Q_ASSERT(m_rootNode);
 
     // we want to rebuild the outline whenever the current document has been reparsed
     connect(ICore::self()->languageController()->backgroundParser(),
             &BackgroundParser::parseJobFinished, this, &OutlineModel::onParseJobFinished);
     // and also when we switch the current document
     connect(docController, &IDocumentController::documentActivated,
             this, &OutlineModel::rebuildOutline);
-    connect(docController, &IDocumentController::documentUrlChanged, this, [this](IDocument* doc) {
+    connect(docController, &IDocumentController::documentClosed,
+            this, [this](IDocument* doc) {
+        if (doc == m_lastDoc) {
+            m_lastDoc = nullptr;
+            m_lastUrl = IndexedString();
+            rebuildOutline(nullptr);
+        }
+    });
+    connect(docController, &IDocumentController::documentUrlChanged,
+            this, [this](IDocument* doc) {
         if (doc == m_lastDoc) {
             m_lastUrl = IndexedString(doc->url());
         }
     });
 
 }
 
 OutlineModel::~OutlineModel()
 {
 }
 
 Qt::ItemFlags OutlineModel::flags(const QModelIndex& index) const
 {
     if (!index.isValid()) {
         return Qt::NoItemFlags;
     } else {
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
     }
 }
 
 int OutlineModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 QVariant OutlineModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     if (index.column() != 0) {
         return QVariant();
     }
 
     OutlineNode* node = static_cast<OutlineNode*>(index.internalPointer());
     Q_ASSERT(node);
     if (role == Qt::DecorationRole) {
         return node->icon();
     }
     if (role == Qt::DisplayRole) {
         return node->text();
     }
     return QVariant();
 }
 
 bool OutlineModel::hasChildren(const QModelIndex& parent) const
 {
     return rowCount(parent) > 0;
 }
 
 int OutlineModel::rowCount(const QModelIndex& parent) const
 {
     if (!parent.isValid()) {
         Q_ASSERT(m_rootNode);
         return m_rootNode->childCount();
     } else if (parent.column() != 0) {
         return 0;
     } else {
         const OutlineNode* node = static_cast<const OutlineNode*>(parent.internalPointer());
         return node->childCount();
     }
 }
 
 QModelIndex OutlineModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent)) {
         return QModelIndex();
     }
     if (!parent.isValid()) {
         // topLevelItem
         if (row < m_rootNode->childCount()) {
             return createIndex(row, column, const_cast<OutlineNode*>(m_rootNode->childAt(row)));
         }
         return QModelIndex();
     } else {
         if (parent.column() != 0) {
             return QModelIndex(); //only column 0 should have children
         }
         OutlineNode* node = static_cast<OutlineNode*>(parent.internalPointer());
         if (row < node->childCount()) {
             return createIndex(row, column, const_cast<OutlineNode*>(node->childAt(row)));
         }
         return QModelIndex(); // out of range
     }
     return QModelIndex();
 }
 
 QModelIndex OutlineModel::parent(const QModelIndex& index) const
 {
     if (!index.isValid()) {
         return QModelIndex();
     }
 
     const OutlineNode* node = static_cast<const OutlineNode*>(index.internalPointer());
 
     const OutlineNode* parentNode = node->parent();
     Q_ASSERT(parentNode);
     if (parentNode == m_rootNode.get()) {
         return QModelIndex(); //node is a top level item
     }
 
     // parent node was not m_rootNode -> parent() must be valid
     const OutlineNode* parentParentNode = parentNode->parent();
     Q_ASSERT(parentNode);
     const int row = parentParentNode->indexOf(parentNode);
     return createIndex(row, 0, const_cast<OutlineNode*>(parentNode));
 }
 
 void OutlineModel::onParseJobFinished(KDevelop::ParseJob* job)
 {
     if (job->document() == m_lastUrl) {
         rebuildOutline(m_lastDoc);
     }
 }
 
 void OutlineModel::rebuildOutline(IDocument* doc)
 {
     emit beginResetModel();
     if (!doc) {
         m_rootNode = OutlineNode::dummyNode();
     } else {
         // TODO: do this in a separate thread? Might take a while for large documents
         // and we really shouldn't be blocking the GUI thread!
         DUChainReadLocker lock;
         TopDUContext* topContext = DUChainUtils::standardContextForUrl(doc->url());
         if (topContext) {
             m_rootNode = OutlineNode::fromTopContext(topContext);
         } else {
             m_rootNode = OutlineNode::dummyNode();
         }
     }
     if (doc != m_lastDoc) {
         m_lastUrl = doc ? IndexedString(doc->url()) : IndexedString();
         m_lastDoc = doc;
     }
     emit endResetModel();
 }
 
 void OutlineModel::activate(const QModelIndex& realIndex)
 {
     if (!realIndex.isValid()) {
         qCWarning(PLUGIN_OUTLINE) << "attempting to activate invalid item!";
         return;
     }
     OutlineNode* node = static_cast<OutlineNode*>(realIndex.internalPointer());
     KTextEditor::Range range;
     {
         DUChainReadLocker lock;
         const DUChainBase* dcb = node->duChainObject();
         if (!dcb) {
             qCDebug(PLUGIN_OUTLINE) << "No declaration exists for node:" << node->text();
             return;
         }
         //foreground thread == GUI thread? if so then we are fine
         range = dcb->rangeInCurrentRevision();
         //outline view should ALWAYS correspond to currently active document
         Q_ASSERT(dcb->url().toUrl() == ICore::self()->documentController()->activeDocument()->url());
         // lock should be released before activating the document
     }
     ICore::self()->documentController()->activateDocument(m_lastDoc, range);
 }
diff --git a/plugins/problemreporter/problemtreeview.cpp b/plugins/problemreporter/problemtreeview.cpp
index 48f0eaf19..59f616638 100644
--- a/plugins/problemreporter/problemtreeview.cpp
+++ b/plugins/problemreporter/problemtreeview.cpp
@@ -1,388 +1,388 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright (c) 2006-2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2006 Adam Treat <treat@kde.org>
  *
  * This program 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 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 "problemtreeview.h"
 
 #include <QAction>
 #include <QContextMenuEvent>
 #include <QHeaderView>
 #include <QIcon>
 #include <QItemDelegate>
 #include <QMenu>
 #include <QSignalMapper>
 #include <QSortFilterProxyModel>
 
 #include <KActionMenu>
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iassistant.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <util/kdevstringhandler.h>
 
 #include "problemreporterplugin.h"
 #include <shell/problemmodel.h>
 #include <shell/problem.h>
 #include <shell/problemconstants.h>
 
 //#include "modeltest.h"
 
 using namespace KDevelop;
 
 namespace KDevelop
 {
 
 class ProblemTreeViewItemDelegate : public QItemDelegate
 {
     Q_OBJECT
 
 public:
     explicit ProblemTreeViewItemDelegate(QObject* parent = nullptr);
 
     void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 };
 }
 
 ProblemTreeViewItemDelegate::ProblemTreeViewItemDelegate(QObject* parent)
     : QItemDelegate(parent)
 {
 }
 
 void ProblemTreeViewItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
                                         const QModelIndex& index) const
 {
     QStyleOptionViewItem newOption(option);
     newOption.textElideMode = index.column() == ProblemModel::File ? Qt::ElideMiddle : Qt::ElideRight;
 
     QItemDelegate::paint(painter, newOption, index);
 }
 
 ProblemTreeView::ProblemTreeView(QWidget* parent, QAbstractItemModel* itemModel)
     : QTreeView(parent)
     , m_proxy(new QSortFilterProxyModel(this))
 {
 
     setObjectName("Problem Reporter Tree");
     setWhatsThis(i18n("Problems"));
-    setItemDelegate(new ProblemTreeViewItemDelegate);
+    setItemDelegate(new ProblemTreeViewItemDelegate(this));
     setSelectionBehavior(QAbstractItemView::SelectRows);
 
     m_proxy->setSortRole(ProblemModel::SeverityRole);
     m_proxy->setDynamicSortFilter(true);
     m_proxy->sort(0, Qt::AscendingOrder);
 
     ProblemModel* problemModel = dynamic_cast<ProblemModel*>(itemModel);
     Q_ASSERT(problemModel);
     setModel(problemModel);
 
     header()->setStretchLastSection(false);
 
     if (problemModel->features().testFlag(ProblemModel::CanDoFullUpdate)) {
         QAction* fullUpdateAction = new QAction(this);
         fullUpdateAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         fullUpdateAction->setText(i18n("Force Full Update"));
         fullUpdateAction->setToolTip(i18nc("@info:tooltip", "Re-parse all watched documents"));
         fullUpdateAction->setIcon(QIcon::fromTheme("view-refresh"));
         connect(fullUpdateAction, &QAction::triggered, model(), &ProblemModel::forceFullUpdate);
         addAction(fullUpdateAction);
     }
 
     if (problemModel->features().testFlag(ProblemModel::CanShowImports)) {
         QAction* showImportsAction = new QAction(this);
         addAction(showImportsAction);
         showImportsAction->setCheckable(true);
         showImportsAction->setChecked(false);
         showImportsAction->setText(i18n("Show Imports"));
         showImportsAction->setToolTip(i18nc("@info:tooltip", "Display problems in imported files"));
         this->model()->setShowImports(false);
         connect(showImportsAction, &QAction::triggered, model(), &ProblemModel::setShowImports);
     }
 
     if (problemModel->features().testFlag(ProblemModel::ScopeFilter)) {
         KActionMenu* scopeMenu = new KActionMenu(this);
         scopeMenu->setDelayed(false);
         scopeMenu->setToolTip(i18nc("@info:tooltip", "Which files to display the problems for"));
         scopeMenu->setObjectName(QStringLiteral("scopeMenu"));
 
         QActionGroup* scopeActions = new QActionGroup(this);
 
         QAction* currentDocumentAction = new QAction(this);
         currentDocumentAction->setText(i18n("Current Document"));
         currentDocumentAction->setToolTip(i18nc("@info:tooltip", "Display problems in current document"));
 
         QAction* openDocumentsAction = new QAction(this);
         openDocumentsAction->setText(i18n("Open Documents"));
         openDocumentsAction->setToolTip(i18nc("@info:tooltip", "Display problems in all open documents"));
 
         QAction* currentProjectAction = new QAction(this);
         currentProjectAction->setText(i18n("Current Project"));
         currentProjectAction->setToolTip(i18nc("@info:tooltip", "Display problems in current project"));
 
         QAction* allProjectAction = new QAction(this);
         allProjectAction->setText(i18n("All Projects"));
         allProjectAction->setToolTip(i18nc("@info:tooltip", "Display problems in all projects"));
 
         QVector<QAction*> actions;
         actions.push_back(currentDocumentAction);
         actions.push_back(openDocumentsAction);
         actions.push_back(currentProjectAction);
         actions.push_back(allProjectAction);
 
         if (problemModel->features().testFlag(ProblemModel::CanByPassScopeFilter)) {
             QAction* showAllAction = new QAction(this);
             showAllAction->setText(i18n("Show All"));
             showAllAction->setToolTip(i18nc("@info:tooltip", "Display ALL problems"));
             actions.push_back(showAllAction);
         }
 
         foreach (QAction* action, actions) {
             action->setCheckable(true);
             scopeActions->addAction(action);
             scopeMenu->addAction(action);
         }
         addAction(scopeMenu);
         setScope(CurrentDocument);
 
         // Show All should be default if it's supported. It helps with error messages that are otherwise invisible
         if (problemModel->features().testFlag(ProblemModel::CanByPassScopeFilter)) {
             actions.last()->setChecked(true);
             model()->setScope(BypassScopeFilter);
         } else {
             currentDocumentAction->setChecked(true);
             model()->setScope(CurrentDocument);
         }
 
         QSignalMapper* scopeMapper = new QSignalMapper(this);
         scopeMapper->setMapping(currentDocumentAction, CurrentDocument);
         scopeMapper->setMapping(openDocumentsAction, OpenDocuments);
         scopeMapper->setMapping(currentProjectAction, CurrentProject);
         scopeMapper->setMapping(allProjectAction, AllProjects);
         connect(currentDocumentAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(openDocumentsAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(currentProjectAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(allProjectAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
 
         if (problemModel->features().testFlag(ProblemModel::CanByPassScopeFilter)) {
             scopeMapper->setMapping(actions.last(), BypassScopeFilter);
             connect(actions.last(), &QAction::triggered, scopeMapper,
                     static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         }
 
         connect(scopeMapper, static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped), this,
                 &ProblemTreeView::setScope);
     }
 
     if (problemModel->features().testFlag(ProblemModel::SeverityFilter)) {
         QActionGroup* severityActions = new QActionGroup(this);
         auto errorSeverityAction = new QAction(this);
         errorSeverityAction->setToolTip(i18nc("@info:tooltip", "Display only errors"));
         errorSeverityAction->setIcon(QIcon::fromTheme("dialog-error"));
 
         auto warningSeverityAction = new QAction(this);
         warningSeverityAction->setToolTip(i18nc("@info:tooltip", "Display errors and warnings"));
         warningSeverityAction->setIcon(QIcon::fromTheme("dialog-warning"));
 
         auto hintSeverityAction = new QAction(this);
         hintSeverityAction->setToolTip(i18nc("@info:tooltip", "Display errors, warnings and hints"));
         hintSeverityAction->setIcon(QIcon::fromTheme("dialog-information"));
 
         QAction* severityActionArray[] = { errorSeverityAction, warningSeverityAction, hintSeverityAction };
         for (int i = 0; i < 3; ++i) {
             severityActionArray[i]->setCheckable(true);
             severityActions->addAction(severityActionArray[i]);
             addAction(severityActionArray[i]);
         }
 
         hintSeverityAction->setChecked(true);
         model()->setSeverity(IProblem::Hint);
         QSignalMapper* severityMapper = new QSignalMapper(this);
         severityMapper->setMapping(errorSeverityAction, IProblem::Error);
         severityMapper->setMapping(warningSeverityAction, IProblem::Warning);
         severityMapper->setMapping(hintSeverityAction, IProblem::Hint);
         connect(errorSeverityAction, &QAction::triggered, severityMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(warningSeverityAction, &QAction::triggered, severityMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(hintSeverityAction, &QAction::triggered, severityMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(severityMapper, static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped), model(),
                 &ProblemModel::setSeverity);
     }
 
     if (problemModel->features().testFlag(ProblemModel::Grouping)) {
         KActionMenu* groupingMenu = new KActionMenu(i18n("Grouping"), this);
         groupingMenu->setDelayed(false);
 
         QActionGroup* groupingActions = new QActionGroup(this);
 
         QAction* noGroupingAction = new QAction(i18n("None"), this);
         QAction* pathGroupingAction = new QAction(i18n("Path"), this);
         QAction* severityGroupingAction = new QAction(i18n("Severity"), this);
 
         QAction* groupingActionArray[] = { noGroupingAction, pathGroupingAction, severityGroupingAction };
         for (unsigned i = 0; i < sizeof(groupingActionArray) / sizeof(QAction*); ++i) {
             QAction* action = groupingActionArray[i];
             action->setCheckable(true);
             groupingActions->addAction(action);
             groupingMenu->addAction(action);
         }
         addAction(groupingMenu);
 
         noGroupingAction->setChecked(true);
         QSignalMapper* groupingMapper = new QSignalMapper(this);
         groupingMapper->setMapping(noGroupingAction, NoGrouping);
         groupingMapper->setMapping(pathGroupingAction, PathGrouping);
         groupingMapper->setMapping(severityGroupingAction, SeverityGrouping);
 
         connect(noGroupingAction, &QAction::triggered, groupingMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(pathGroupingAction, &QAction::triggered, groupingMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(severityGroupingAction, &QAction::triggered, groupingMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
 
         connect(groupingMapper, static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped), model(),
                 &ProblemModel::setGrouping);
     }
 
     connect(this, &ProblemTreeView::clicked, this, &ProblemTreeView::itemActivated);
 
     connect(model(), &QAbstractItemModel::rowsInserted, this, &ProblemTreeView::changed);
     connect(model(), &QAbstractItemModel::rowsRemoved, this, &ProblemTreeView::changed);
     connect(model(), &QAbstractItemModel::modelReset, this, &ProblemTreeView::changed);
 }
 
 ProblemTreeView::~ProblemTreeView()
 {
 }
 
 void ProblemTreeView::openDocumentForCurrentProblem()
 {
     itemActivated(currentIndex());
 }
 
 void ProblemTreeView::itemActivated(const QModelIndex& index)
 {
     if (!index.isValid())
         return;
 
     KTextEditor::Cursor start;
     QUrl url;
 
     {
         // TODO: is this really necessary?
         DUChainReadLocker lock(DUChain::lock());
         const auto problem = index.data(ProblemModel::ProblemRole).value<IProblem::Ptr>();
         if (!problem)
             return;
 
         url = problem->finalLocation().document.toUrl();
         start = problem->finalLocation().start();
     }
 
     ICore::self()->documentController()->openDocument(url, start);
 }
 
 void ProblemTreeView::setScope(int scope)
 {
     foreach (auto action, actions()) {
         if (action->objectName() == QLatin1String("scopeMenu")) {
             action->setText(i18n("Scope: %1", action->menu()->actions().at(scope)->text()));
         }
     }
 
     model()->setScope(scope);
 }
 
 void ProblemTreeView::resizeColumns()
 {
     for (int i = 0; i < model()->columnCount(); ++i)
         resizeColumnToContents(i);
 }
 
 void ProblemTreeView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
 {
     QTreeView::dataChanged(topLeft, bottomRight, roles);
     resizeColumns();
 }
 
 void ProblemTreeView::reset()
 {
     QTreeView::reset();
     resizeColumns();
 }
 
 ProblemModel* ProblemTreeView::model() const
 {
     return static_cast<ProblemModel*>(m_proxy->sourceModel());
 }
 
 void ProblemTreeView::setModel(QAbstractItemModel* model)
 {
     Q_ASSERT(qobject_cast<ProblemModel*>(model));
     m_proxy->setSourceModel(model);
     QTreeView::setModel(m_proxy);
 }
 
 void ProblemTreeView::contextMenuEvent(QContextMenuEvent* event)
 {
     QModelIndex index = indexAt(event->pos());
     if (index.isValid()) {
         const auto problem = index.data(ProblemModel::ProblemRole).value<IProblem::Ptr>();
         if (!problem) {
             return;
         }
         QExplicitlySharedDataPointer<KDevelop::IAssistant> solution = problem->solutionAssistant();
         if (!solution) {
             return;
         }
         QList<QAction*> actions;
         foreach (KDevelop::IAssistantAction::Ptr action, solution->actions()) {
             actions << action->toKAction();
         }
         if (!actions.isEmpty()) {
             QString title = solution->title();
             title = KDevelop::htmlToPlainText(title);
             title.replace("&apos;", "\'");
 
             QPointer<QMenu> m = new QMenu(this);
             m->addSection(title);
             m->addActions(actions);
             m->exec(event->globalPos());
             delete m;
         }
     }
 }
 
 void ProblemTreeView::showEvent(QShowEvent* event)
 {
     Q_UNUSED(event)
     resizeColumns();
 }
 
 #include "problemtreeview.moc"
diff --git a/plugins/projectmanagerview/projecttreeview.cpp b/plugins/projectmanagerview/projecttreeview.cpp
index 0544e4abe..81ba3ab80 100644
--- a/plugins/projectmanagerview/projecttreeview.cpp
+++ b/plugins/projectmanagerview/projecttreeview.cpp
@@ -1,461 +1,460 @@
 /* This file is part of KDevelop
     Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2009 Aleix Pol <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 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 "projecttreeview.h"
 
 
 #include <QAction>
 #include <QAbstractProxyModel>
 #include <QApplication>
 #include <QHeaderView>
 #include <QMenu>
 #include <QMouseEvent>
 #include <QPainter>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include <project/projectmodel.h>
 #include <language/duchain/duchainutils.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/context.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/iselectioncontroller.h>
 #include <interfaces/isession.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 
 #include "projectmanagerviewplugin.h"
 #include "projectmodelsaver.h"
 #include "projectmodelitemdelegate.h"
 #include "debug.h"
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/util/navigationtooltip.h>
 #include <project/projectutils.h>
 #include <widgetcolorizer.h>
 
 using namespace KDevelop;
 
 namespace {
 const char settingsConfigGroup[] = "ProjectTreeView";
 
 QList<ProjectFileItem*> fileItemsWithin(const QList<ProjectBaseItem*>& items)
 {
     QList<ProjectFileItem*> fileItems;
     fileItems.reserve(items.size());
     foreach(ProjectBaseItem* item, items)
     {
         if (ProjectFileItem *file = item->file())
             fileItems.append(file);
         else if (item->folder())
             fileItems.append(fileItemsWithin(item->children()));
     }
     return fileItems;
 }
 
 QList<ProjectBaseItem*> topLevelItemsWithin(QList<ProjectBaseItem*> items)
 {
     std::sort(items.begin(), items.end(), ProjectBaseItem::pathLessThan);
     Path lastFolder;
     for (int i = items.size() - 1; i >= 0; --i)
     {
         if (lastFolder.isParentOf(items[i]->path()))
             items.removeAt(i);
         else if (items[i]->folder())
             lastFolder = items[i]->path();
     }
     return items;
 }
 
 template<class T>
 void filterDroppedItems(QList<T*> &items, ProjectBaseItem* dest)
 {
     for (int i = items.size() - 1; i >= 0; --i)
     {
         //No drag and drop from and to same location
         if (items[i]->parent() == dest)
             items.removeAt(i);
         //No moving between projects (technically feasible if the projectmanager is the same though...)
         else if (items[i]->project() != dest->project())
             items.removeAt(i);
     }
 }
 
 //TODO test whether this could be replaced by projectbuildsetwidget.cpp::showContextMenu_appendActions
 void popupContextMenu_appendActions(QMenu& menu, const QList<QAction*>& actions)
 {
     menu.addActions(actions);
     menu.addSeparator();
 }
 
 }
 
 ProjectTreeView::ProjectTreeView( QWidget *parent )
         : QTreeView( parent ), m_ctxProject( 0 )
 {
     header()->hide();
 
     setEditTriggers( QAbstractItemView::EditKeyPressed );
 
     setContextMenuPolicy( Qt::CustomContextMenu );
     setSelectionMode( QAbstractItemView::ExtendedSelection );
 
     setIndentation(10);
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::InternalMove);
     setAutoScroll(true);
     setAutoExpandDelay(300);
     setItemDelegate(new ProjectModelItemDelegate(this));
 
     connect( this, &ProjectTreeView::customContextMenuRequested, this, &ProjectTreeView::popupContextMenu );
     connect( this, &ProjectTreeView::activated, this, &ProjectTreeView::slotActivated );
 
     connect( ICore::self(), &ICore::aboutToShutdown,
              this, &ProjectTreeView::aboutToShutdown);
     connect( ICore::self()->projectController(), &IProjectController::projectOpened,
              this, &ProjectTreeView::restoreState );
     connect( ICore::self()->projectController(), &IProjectController::projectClosing,
              this, &ProjectTreeView::saveState );
 
     restoreState();
 }
 
 ProjectTreeView::~ProjectTreeView()
 {
 }
 
 ProjectBaseItem* ProjectTreeView::itemAtPos(QPoint pos)
 {
     return indexAt(pos).data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>();
 }
 
 void ProjectTreeView::dropEvent(QDropEvent* event)
 {
     ProjectItemContext* selectionCtxt =
             static_cast<ProjectItemContext*>(KDevelop::ICore::self()->selectionController()->currentSelection());
     ProjectBaseItem* destItem = itemAtPos(event->pos());
     if (destItem && (dropIndicatorPosition() == AboveItem || dropIndicatorPosition() == BelowItem))
             destItem = destItem->parent();
     if (selectionCtxt && destItem)
     {
         if (ProjectFolderItem *folder = destItem->folder())
         {
             QMenu dropMenu(this);
 
             QString seq = QKeySequence( Qt::ShiftModifier ).toString();
             seq.chop(1); // chop superfluous '+'
             QAction* move = new QAction(i18n( "&Move Here" ) + '\t' + seq, &dropMenu);
             move->setIcon(QIcon::fromTheme("go-jump"));
             dropMenu.addAction(move);
 
             seq = QKeySequence( Qt::ControlModifier ).toString();
             seq.chop(1);
             QAction* copy = new QAction(i18n( "&Copy Here" ) + '\t' + seq, &dropMenu);
             copy->setIcon(QIcon::fromTheme("edit-copy"));
             dropMenu.addAction(copy);
 
             dropMenu.addSeparator();
 
             QAction* cancel = new QAction(i18n( "C&ancel" ) + '\t' + QKeySequence( Qt::Key_Escape ).toString(), &dropMenu);
             cancel->setIcon(QIcon::fromTheme("process-stop"));
             dropMenu.addAction(cancel);
 
             QAction *executedAction = 0;
 
             Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
             if (modifiers == Qt::ControlModifier) {
                 executedAction = copy;
             } else if (modifiers == Qt::ShiftModifier) {
                 executedAction = move;
             } else {
                 executedAction = dropMenu.exec(this->mapToGlobal(event->pos()));
             }
 
             QList<ProjectBaseItem*> usefulItems = topLevelItemsWithin(selectionCtxt->items());
             filterDroppedItems(usefulItems, destItem);
             Path::List paths;
             foreach (ProjectBaseItem* i, usefulItems) {
                 paths << i->path();
             }
             bool success = false;
             if (executedAction == copy) {
                 success = destItem->project()->projectFileManager()->copyFilesAndFolders(paths, folder);
             } else if (executedAction == move) {
                 success = destItem->project()->projectFileManager()->moveFilesAndFolders(usefulItems, folder);
             }
 
             if (success) {
                 //expand target folder
                 expand( mapFromItem(folder));
 
                 //and select new items
                 QItemSelection selection;
                 foreach (const Path &path, paths) {
                     const Path targetPath(folder->path(), path.lastPathSegment());
                     foreach (ProjectBaseItem *item, folder->children()) {
                         if (item->path() == targetPath) {
                             QModelIndex indx = mapFromItem( item );
                             selection.append(QItemSelectionRange(indx, indx));
                             setCurrentIndex(indx);
                         }
                     }
                 }
                 selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
             }
         }
         else if (destItem->target() && destItem->project()->buildSystemManager())
         {
             QMenu dropMenu(this);
 
             QString seq = QKeySequence( Qt::ControlModifier ).toString();
             seq.chop(1);
             QAction* addToTarget = new QAction(i18n( "&Add to Target" ) + '\t' + seq, &dropMenu);
             addToTarget->setIcon(QIcon::fromTheme("edit-link"));
             dropMenu.addAction(addToTarget);
 
             dropMenu.addSeparator();
 
             QAction* cancel = new QAction(i18n( "C&ancel" ) + '\t' + QKeySequence( Qt::Key_Escape ).toString(), &dropMenu);
             cancel->setIcon(QIcon::fromTheme("process-stop"));
             dropMenu.addAction(cancel);
 
             QAction *executedAction = 0;
 
             Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
             if (modifiers == Qt::ControlModifier) {
                 executedAction = addToTarget;
             } else {
                 executedAction = dropMenu.exec(this->mapToGlobal(event->pos()));
             }
             if (executedAction == addToTarget) {
                 QList<ProjectFileItem*> usefulItems = fileItemsWithin(selectionCtxt->items());
                 filterDroppedItems(usefulItems, destItem);
                 destItem->project()->buildSystemManager()->addFilesToTarget(usefulItems, destItem->target());
             }
         }
     }
     event->accept();
 }
 
 QModelIndex ProjectTreeView::mapFromSource(const QAbstractProxyModel* proxy, const QModelIndex& sourceIdx)
 {
     const QAbstractItemModel* next = proxy->sourceModel();
     Q_ASSERT(next == sourceIdx.model() || qobject_cast<const QAbstractProxyModel*>(next));
     if(next == sourceIdx.model())
         return proxy->mapFromSource(sourceIdx);
     else {
         const QAbstractProxyModel* nextProxy = qobject_cast<const QAbstractProxyModel*>(next);
         QModelIndex idx = mapFromSource(nextProxy, sourceIdx);
         Q_ASSERT(idx.model() == nextProxy);
         return proxy->mapFromSource(idx);
     }
 }
 
 QModelIndex ProjectTreeView::mapFromItem(const ProjectBaseItem* item)
 {
     QModelIndex ret = mapFromSource(qobject_cast<const QAbstractProxyModel*>(model()), item->index());
     Q_ASSERT(ret.model() == model());
     return ret;
 }
 
 void ProjectTreeView::slotActivated( const QModelIndex &index )
 {
     if ( QApplication::keyboardModifiers() & Qt::CTRL || QApplication::keyboardModifiers() & Qt::SHIFT ) {
         // Do not open file when Ctrl or Shift is pressed; that's for selection
         return;
     }
     KDevelop::ProjectBaseItem *item = index.data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>();
     if ( item && item->file() )
     {
         emit activate( item->file()->path() );
     }
 }
 
 void ProjectTreeView::popupContextMenu( const QPoint &pos )
 {
     QList<KDevelop::ProjectBaseItem*> itemlist;
 
     if ( indexAt(pos).isValid() )
     {
         QModelIndexList indexes = selectionModel()->selectedRows();
         foreach( const QModelIndex& index, indexes )
         {
             if ( KDevelop::ProjectBaseItem *item = index.data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>() )
                 itemlist << item;
         }
     }
 
     if( !itemlist.isEmpty() )
     {
         m_ctxProject = itemlist.at(0)->project();
     } else
     {
         m_ctxProject = 0;
     }
 
     QMenu menu( this );
 
     KDevelop::ProjectItemContextImpl context(itemlist);
     QList<ContextMenuExtension> extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions( &context );
 
     QList<QAction*> buildActions;
     QList<QAction*> vcsActions;
     QList<QAction*> extActions;
     QList<QAction*> projectActions;
     QList<QAction*> fileActions;
     QList<QAction*> runActions;
     foreach( const ContextMenuExtension& ext, extensions )
     {
         buildActions += ext.actions(ContextMenuExtension::BuildGroup);
         fileActions += ext.actions(ContextMenuExtension::FileGroup);
         projectActions += ext.actions(ContextMenuExtension::ProjectGroup);
         vcsActions += ext.actions(ContextMenuExtension::VcsGroup);
         extActions += ext.actions(ContextMenuExtension::ExtensionGroup);
         runActions += ext.actions(ContextMenuExtension::RunGroup);
     }
 
     popupContextMenu_appendActions(menu, buildActions);
     popupContextMenu_appendActions(menu, runActions );
     popupContextMenu_appendActions(menu, fileActions);
     popupContextMenu_appendActions(menu, vcsActions);
     popupContextMenu_appendActions(menu, extActions);
 
     if ( !itemlist.isEmpty() && itemlist.size() == 1 && itemlist[0]->folder() && !itemlist[0]->folder()->parent() )
     {
         QAction* projectConfig = new QAction(i18n("Open Configuration..."), this);
         projectConfig->setIcon(QIcon::fromTheme("configure"));
         connect( projectConfig, &QAction::triggered, this, &ProjectTreeView::openProjectConfig );
         projectActions << projectConfig;
     }
     popupContextMenu_appendActions(menu, projectActions);
 
     if(!itemlist.isEmpty())
         KDevelop::populateParentItemsMenu(itemlist.front(), &menu);
 
     if ( !menu.isEmpty() ) {
         menu.exec( mapToGlobal( pos ) );
     }
 }
 
 void ProjectTreeView::openProjectConfig()
 {
     if( m_ctxProject )
     {
         IProjectController* ip = ICore::self()->projectController();
         ip->configureProject( m_ctxProject );
     }
 }
 
 void ProjectTreeView::saveState()
 {
     KConfigGroup configGroup( ICore::self()->activeSession()->config(), settingsConfigGroup );
 
     ProjectModelSaver saver;
     saver.setView( this );
     saver.saveState( configGroup );
 }
 
 void ProjectTreeView::restoreState(IProject* project)
 {
     KConfigGroup configGroup( ICore::self()->activeSession()->config(), settingsConfigGroup );
 
-    // Saver will delete itself when it is complete.
-    ProjectModelSaver *saver = new ProjectModelSaver;
-    saver->setProject( project );
-    saver->setView( this );
-    saver->restoreState( configGroup );
+    ProjectModelSaver saver;
+    saver.setProject( project );
+    saver.setView( this );
+    saver.restoreState( configGroup );
 }
 
 void ProjectTreeView::aboutToShutdown()
 {
     // save all projects, not just the last one that is closed
     disconnect( ICore::self()->projectController(), &IProjectController::projectClosing,
                 this, &ProjectTreeView::saveState );
     saveState();
 }
 
 bool ProjectTreeView::event(QEvent* event)
 {
     if(event->type()==QEvent::ToolTip)
     {
         QPoint p = mapFromGlobal(QCursor::pos());
         QModelIndex idxView = indexAt(p);
 
         ProjectBaseItem* it = idxView.data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>();
         QModelIndex idx;
         if(it)
             idx = it->index();
 
         if((m_idx!=idx || !m_tooltip) && it && it->file())
         {
             m_idx=idx;
             ProjectFileItem* file=it->file();
             KDevelop::DUChainReadLocker lock(KDevelop::DUChain::lock());
             TopDUContext* top= DUChainUtils::standardContextForUrl(file->path().toUrl());
 
             if(m_tooltip)
                 m_tooltip->close();
 
             if(top)
             {
                 QWidget* navigationWidget = top->createNavigationWidget();
                 if( navigationWidget )
                 {
                     m_tooltip = new KDevelop::NavigationToolTip(this, mapToGlobal(p) + QPoint(40, 0), navigationWidget);
                     m_tooltip->resize( navigationWidget->sizeHint() + QSize(10, 10) );
                     qCDebug(PLUGIN_PROJECTMANAGERVIEW) << "tooltip size" << m_tooltip->size();
                     ActiveToolTip::showToolTip(m_tooltip);
                     return true;
                 }
             }
         }
     }
 
     return QAbstractItemView::event(event);
 }
 
 void ProjectTreeView::keyPressEvent(QKeyEvent* event)
 {
     if (event->key() == Qt::Key_Return && currentIndex().isValid() && state()!=QAbstractItemView::EditingState)
     {
         event->accept();
         slotActivated(currentIndex());
     }
     else
         QTreeView::keyPressEvent(event);
 }
 
 void ProjectTreeView::drawBranches(QPainter* painter, const QRect& rect, const QModelIndex& index) const
 {
     const bool colorizeByProject = KSharedConfig::openConfig()->group("UiSettings").readEntry("ColorizeByProject", false);
     if (colorizeByProject) {
         const auto projectPath = index.data(ProjectModel::ProjectRole).value<IProject *>()->path();
         const QColor color = WidgetColorizer::colorForId(qHash(projectPath), palette());
         WidgetColorizer::drawBranches(this, painter, rect, index, color);
     }
 
     QTreeView::drawBranches(painter, rect, index);
 }
diff --git a/project/projectmodel.cpp b/project/projectmodel.cpp
index 9b41aa1df..17bf41810 100644
--- a/project/projectmodel.cpp
+++ b/project/projectmodel.cpp
@@ -1,1189 +1,1191 @@
 /* This file is part of KDevelop
     Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Aleix Pol <aleixpol@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 "projectmodel.h"
 
 #include <QDebug>
 #include <QIcon>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 #include <KIO/StatJob>
 #include <KLocalizedString>
 
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/icore.h>
 #include "interfaces/iprojectfilemanager.h"
 #include <serialization/indexedstring.h>
 
 #include "path.h"
 
 namespace KDevelop
 {
 
 QStringList removeProjectBasePath( const QStringList& fullpath, KDevelop::ProjectBaseItem* item )
 {
     QStringList result = fullpath;
     if( item )
     {
         KDevelop::ProjectModel* model = KDevelop::ICore::self()->projectController()->projectModel();
         QStringList basePath = model->pathFromIndex( model->indexFromItem( item ) );
         if( basePath.count() >= fullpath.count() )
         {
             return QStringList();
         }
         for( int i = 0; i < basePath.count(); i++ )
         {
             result.takeFirst();
         }
     }
     return result;
 }
 
 QStringList joinProjectBasePath( const QStringList& partialpath, KDevelop::ProjectBaseItem* item )
 {
     QStringList basePath;
     if( item )
     {
         KDevelop::ProjectModel* model = KDevelop::ICore::self()->projectController()->projectModel();
         basePath = model->pathFromIndex( model->indexFromItem( item ) );
     }
     return basePath + partialpath;
 }
 
 inline uint indexForPath( const Path& path )
 {
     return IndexedString::indexForString(path.pathOrUrl());
 }
 
 class ProjectModelPrivate
 {
 public:
     ProjectModelPrivate( ProjectModel* model ): model( model )
     {
     }
     ProjectBaseItem* rootItem;
     ProjectModel* model;
     ProjectBaseItem* itemFromIndex( const QModelIndex& idx ) {
         if( !idx.isValid() ) {
             return rootItem;
         }
         if( idx.model() != model ) {
             return 0;
         }
         return model->itemFromIndex( idx );
     }
 
     // a hash of IndexedString::indexForString(path) <-> ProjectBaseItem for fast lookup
     QMultiHash<uint, ProjectBaseItem*> pathLookupTable;
 };
 
 class ProjectBaseItemPrivate
 {
 public:
     ProjectBaseItemPrivate() : project(0), parent(0), row(-1), model(0), m_pathIndex(0) {}
     IProject* project;
     ProjectBaseItem* parent;
     int row;
     QList<ProjectBaseItem*> children;
     QString text;
     ProjectBaseItem::ProjectItemType type;
     Qt::ItemFlags flags;
     ProjectModel* model;
     Path m_path;
     uint m_pathIndex;
     QString iconName;
 
     ProjectBaseItem::RenameStatus renameBaseItem(ProjectBaseItem* item, const QString& newName)
     {
         if (item->parent()) {
             foreach(ProjectBaseItem* sibling, item->parent()->children()) {
                 if (sibling->text() == newName) {
                     return ProjectBaseItem::ExistingItemSameName;
                 }
             }
         }
         item->setText( newName );
         return ProjectBaseItem::RenameOk;
     }
 
     ProjectBaseItem::RenameStatus renameFileOrFolder(ProjectBaseItem* item, const QString& newName)
     {
         Q_ASSERT(item->file() || item->folder());
 
         if (newName.contains('/')) {
             return ProjectBaseItem::InvalidNewName;
         }
 
         if (item->text() == newName) {
             return ProjectBaseItem::RenameOk;
         }
 
         Path newPath = item->path();
         newPath.setLastPathSegment(newName);
 
         auto job = KIO::stat(newPath.toUrl(), KIO::StatJob::SourceSide, 0);
         if (job->exec()) {
             // file/folder exists already
             return ProjectBaseItem::ExistingItemSameName;
         }
 
         if( !item->project() || !item->project()->projectFileManager() ) {
             return renameBaseItem(item, newName);
         } else if( item->folder() && item->project()->projectFileManager()->renameFolder(item->folder(), newPath) ) {
             return ProjectBaseItem::RenameOk;
         } else if ( item->file() && item->project()->projectFileManager()->renameFile(item->file(), newPath) ) {
             return ProjectBaseItem::RenameOk;
         } else {
             return ProjectBaseItem::ProjectManagerRenameFailed;
         }
     }
 };
 
 
 ProjectBaseItem::ProjectBaseItem( IProject* project, const QString &name, ProjectBaseItem *parent )
         : d_ptr(new ProjectBaseItemPrivate)
 {
     Q_ASSERT(!name.isEmpty() || !parent);
     Q_D(ProjectBaseItem);
     d->project = project;
     d->text = name;
     d->flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     if( parent ) {
         parent->appendRow( this );
     }
 }
 
 ProjectBaseItem::~ProjectBaseItem()
 {
     Q_D(ProjectBaseItem);
 
     if (model() && d->m_pathIndex) {
         model()->d->pathLookupTable.remove(d->m_pathIndex, this);
     }
 
     if( parent() ) {
         parent()->takeRow( d->row );
     } else if( model() ) {
         model()->takeRow( d->row );
     }
     removeRows(0, d->children.size());
     delete d;
 }
 
 ProjectBaseItem* ProjectBaseItem::child( int row ) const
 {
     Q_D(const ProjectBaseItem);
     if( row < 0 || row >= d->children.length() ) {
         return 0;
     }
     return d->children.at( row );
 }
 
 QList< ProjectBaseItem* > ProjectBaseItem::children() const
 {
     Q_D(const ProjectBaseItem);
     return d->children;
 }
 
 ProjectBaseItem* ProjectBaseItem::takeRow(int row)
 {
     Q_D(ProjectBaseItem);
     Q_ASSERT(row >= 0 && row < d->children.size());
 
     if( model() ) {
         model()->beginRemoveRows(index(), row, row);
     }
     ProjectBaseItem* olditem = d->children.takeAt( row );
     olditem->d_func()->parent = 0;
     olditem->d_func()->row = -1;
     olditem->setModel( 0 );
 
     for(int i=row; i<rowCount(); i++) {
         child(i)->d_func()->row--;
         Q_ASSERT(child(i)->d_func()->row==i);
     }
 
     if( model() ) {
         model()->endRemoveRows();
     }
     return olditem;
 }
 
 void ProjectBaseItem::removeRow( int row )
 {
     delete takeRow( row );
 }
 
 void ProjectBaseItem::removeRows(int row, int count)
 {
     if (!count) {
         return;
     }
 
     Q_D(ProjectBaseItem);
     Q_ASSERT(row >= 0 && row + count <= d->children.size());
 
     if( model() ) {
         model()->beginRemoveRows(index(), row, row + count - 1);
     }
 
     //NOTE: we unset parent, row and model manually to speed up the deletion
     if (row == 0 && count == d->children.size()) {
         // optimize if we want to delete all
         foreach(ProjectBaseItem* item, d->children) {
             item->d_func()->parent = 0;
             item->d_func()->row = -1;
             item->setModel( 0 );
             delete item;
         }
         d->children.clear();
     } else {
         for (int i = row; i < count; ++i) {
             ProjectBaseItem* item = d->children.at(i);
             item->d_func()->parent = 0;
             item->d_func()->row = -1;
             item->setModel( 0 );
             delete d->children.takeAt( row );
         }
         for(int i = row; i < d->children.size(); ++i) {
             d->children.at(i)->d_func()->row--;
             Q_ASSERT(child(i)->d_func()->row==i);
         }
     }
 
     if( model() ) {
         model()->endRemoveRows();
     }
 }
 
 QModelIndex ProjectBaseItem::index() const
 {
     if( model() ) {
         return model()->indexFromItem( this );
     }
     return QModelIndex();
 }
 
 int ProjectBaseItem::rowCount() const
 {
     Q_D(const ProjectBaseItem);
     return d->children.count();
 }
 
 int ProjectBaseItem::type() const
 {
     return ProjectBaseItem::BaseItem;
 }
 
 ProjectModel* ProjectBaseItem::model() const
 {
     Q_D(const ProjectBaseItem);
     return d->model;
 }
 
 ProjectBaseItem* ProjectBaseItem::parent() const
 {
     Q_D(const ProjectBaseItem);
     if( model() && model()->d->rootItem == d->parent ) {
         return 0;
     }
     return d->parent;
 }
 
 int ProjectBaseItem::row() const
 {
     Q_D(const ProjectBaseItem);
     return d->row;
 }
 
 QString ProjectBaseItem::text() const
 {
     Q_D(const ProjectBaseItem);
     if( project() && !parent() ) {
         return project()->name();
     } else {
         return d->text;
     }
 }
 
 void ProjectBaseItem::setModel( ProjectModel* model )
 {
     Q_D(ProjectBaseItem);
 
     if (model == d->model) {
         return;
     }
 
     if (d->model && d->m_pathIndex) {
         d->model->d->pathLookupTable.remove(d->m_pathIndex, this);
     }
 
     d->model = model;
 
     if (model && d->m_pathIndex) {
         model->d->pathLookupTable.insert(d->m_pathIndex, this);
     }
 
     foreach( ProjectBaseItem* item, d->children ) {
         item->setModel( model );
     }
 }
 
 void ProjectBaseItem::setRow( int row )
 {
     Q_D(ProjectBaseItem);
     d->row = row;
 }
 
 void ProjectBaseItem::setText( const QString& text )
 {
     Q_ASSERT(!text.isEmpty() || !parent());
     Q_D(ProjectBaseItem);
     d->text = text;
     if( d->model ) {
         QModelIndex idx = index();
         emit d->model->dataChanged(idx, idx);
     }
 }
 
 ProjectBaseItem::RenameStatus ProjectBaseItem::rename(const QString& newName)
 {
     Q_D(ProjectBaseItem);
     return d->renameBaseItem(this, newName);
 }
 
 KDevelop::ProjectBaseItem::ProjectItemType baseType( int type )
 {
     if( type == KDevelop::ProjectBaseItem::Folder || type == KDevelop::ProjectBaseItem::BuildFolder )
         return KDevelop::ProjectBaseItem::Folder;
     if( type == KDevelop::ProjectBaseItem::Target || type == KDevelop::ProjectBaseItem::ExecutableTarget
         || type == KDevelop::ProjectBaseItem::LibraryTarget)
         return KDevelop::ProjectBaseItem::Target;
 
     return static_cast<KDevelop::ProjectBaseItem::ProjectItemType>( type );
 }
 
 bool ProjectBaseItem::lessThan( const KDevelop::ProjectBaseItem* item ) const
 {
     if(item->type() >= KDevelop::ProjectBaseItem::CustomProjectItemType ) {
         // For custom types we want to make sure that if they override lessThan, then we
         // prefer their lessThan implementation
         return !item->lessThan( this );
     }
     KDevelop::ProjectBaseItem::ProjectItemType leftType=baseType(type()), rightType=baseType(item->type());
     if(leftType==rightType)
     {
         if(leftType==KDevelop::ProjectBaseItem::File)
         {
             return file()->fileName().compare(item->file()->fileName(), Qt::CaseInsensitive) < 0;
         }
         return this->text()<item->text();
     }
     else
     {
         return leftType<rightType;
     }
 
     return false;
 }
 
 bool ProjectBaseItem::pathLessThan(ProjectBaseItem* item1, ProjectBaseItem* item2)
 {
     return item1->path() < item2->path();
 }
 
 IProject* ProjectBaseItem::project() const
 {
     Q_D(const ProjectBaseItem);
     return d->project;
 }
 
 void ProjectBaseItem::appendRow( ProjectBaseItem* item )
 {
     Q_D(ProjectBaseItem);
     if( !item ) {
         return;
     }
     if( item->parent() ) {
         // Proper way is to first removeRow() on the original parent, then appendRow on this one
         qWarning() << "Ignoring double insertion of item" << item;
         return;
     }
     // this is too slow... O(n) and thankfully not a problem anyways
 //     Q_ASSERT(!d->children.contains(item));
     int startrow,endrow;
     if( model() ) {
         startrow = endrow = d->children.count();
         model()->beginInsertRows(index(), startrow, endrow);
     }
     d->children.append( item );
     item->setRow( d->children.count() - 1 );
     item->d_func()->parent = this;
     item->setModel( model() );
     if( model() ) {
         model()->endInsertRows();
     }
 }
 
 Path ProjectBaseItem::path() const
 {
     Q_D(const ProjectBaseItem);
     return d->m_path;
 }
 
 QString ProjectBaseItem::baseName() const
 {
     return text();
 }
 
 void ProjectBaseItem::setPath( const Path& path)
 {
     Q_D(ProjectBaseItem);
 
     if (model() && d->m_pathIndex) {
         model()->d->pathLookupTable.remove(d->m_pathIndex, this);
     }
 
     d->m_path = path;
     d->m_pathIndex = indexForPath(path);
     setText( path.lastPathSegment() );
 
     if (model() && d->m_pathIndex) {
         model()->d->pathLookupTable.insert(d->m_pathIndex, this);
     }
 }
 
 Qt::ItemFlags ProjectBaseItem::flags()
 {
     Q_D(ProjectBaseItem);
     return d->flags;
 }
 
 Qt::DropActions ProjectModel::supportedDropActions() const
 {
     return (Qt::DropActions)(Qt::MoveAction);
 }
 
 void ProjectBaseItem::setFlags(Qt::ItemFlags flags)
 {
     Q_D(ProjectBaseItem);
     d->flags = flags;
     if(d->model)
         d->model->dataChanged(index(), index());
 }
 
 QString ProjectBaseItem::iconName() const
 {
     return "";
 }
 
 ProjectFolderItem *ProjectBaseItem::folder() const
 {
     return 0;
 }
 
 ProjectTargetItem *ProjectBaseItem::target() const
 {
     return 0;
 }
 
 ProjectExecutableTargetItem *ProjectBaseItem::executable() const
 {
     return 0;
 }
 
 ProjectFileItem *ProjectBaseItem::file() const
 {
     return 0;
 }
 
 QList<ProjectFolderItem*> ProjectBaseItem::folderList() const
 {
     QList<ProjectFolderItem*> lst;
     for ( int i = 0; i < rowCount(); ++i )
     {
         ProjectBaseItem* item = child( i );
         if ( item->type() == Folder || item->type() == BuildFolder )
         {
             ProjectFolderItem *kdevitem = dynamic_cast<ProjectFolderItem*>( item );
             if ( kdevitem )
                 lst.append( kdevitem );
         }
     }
 
     return lst;
 }
 
 QList<ProjectTargetItem*> ProjectBaseItem::targetList() const
 {
     QList<ProjectTargetItem*> lst;
     for ( int i = 0; i < rowCount(); ++i )
     {
         ProjectBaseItem* item = child( i );
 
         if ( item->type() == Target || item->type() == LibraryTarget || item->type() == ExecutableTarget )
         {
             ProjectTargetItem *kdevitem = dynamic_cast<ProjectTargetItem*>( item );
             if ( kdevitem )
                 lst.append( kdevitem );
         }
     }
 
     return lst;
 }
 
 QList<ProjectFileItem*> ProjectBaseItem::fileList() const
 {
     QList<ProjectFileItem*> lst;
     for ( int i = 0; i < rowCount(); ++i )
     {
         ProjectBaseItem* item = child( i );
         Q_ASSERT(item);
         if ( item && item->type() == File )
         {
             ProjectFileItem *kdevitem = dynamic_cast<ProjectFileItem*>( item );
             if ( kdevitem )
                 lst.append( kdevitem );
         }
 
     }
     return lst;
 }
 
 void ProjectModel::clear()
 {
     d->rootItem->removeRows(0, d->rootItem->rowCount());
 }
 
 
 ProjectFolderItem::ProjectFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
     : ProjectBaseItem( project, path.lastPathSegment(), parent )
 {
     setPath( path );
 
     setFlags(flags() | Qt::ItemIsDropEnabled);
     if (project && project->path() != path)
         setFlags(flags() | Qt::ItemIsDragEnabled);
 }
 
 ProjectFolderItem::ProjectFolderItem( const QString & name, ProjectBaseItem * parent )
         : ProjectBaseItem( parent->project(), name, parent )
 {
     setPath( Path(parent->path(), name) );
 
     setFlags(flags() | Qt::ItemIsDropEnabled);
     if (project() && project()->path() != path())
         setFlags(flags() | Qt::ItemIsDragEnabled);
 }
 
 ProjectFolderItem::~ProjectFolderItem()
 {
 }
 
 void ProjectFolderItem::setPath( const Path& path )
 {
     ProjectBaseItem::setPath(path);
 
     propagateRename(path);
 }
 
 ProjectFolderItem *ProjectFolderItem::folder() const
 {
     return const_cast<ProjectFolderItem*>(this);
 }
 
 int ProjectFolderItem::type() const
 {
     return ProjectBaseItem::Folder;
 }
 
 QString ProjectFolderItem::folderName() const
 {
     return baseName();
 }
 
 void ProjectFolderItem::propagateRename( const Path& newBase ) const
 {
     Path path = newBase;
     path.addPath(QStringLiteral("dummy"));
     foreach( KDevelop::ProjectBaseItem* child, children() )
     {
         path.setLastPathSegment( child->text() );
         child->setPath( path );
 
         const ProjectFolderItem* folder = child->folder();
         if ( folder ) {
             folder->propagateRename( path );
         }
     }
 }
 
 ProjectBaseItem::RenameStatus ProjectFolderItem::rename(const QString& newName)
 {
     return d_ptr->renameFileOrFolder(this, newName);
 }
 
 bool ProjectFolderItem::hasFileOrFolder(const QString& name) const
 {
     foreach ( ProjectBaseItem* item, children() )
     {
         if ( (item->type() == Folder || item->type() == File || item->type() == BuildFolder)
              && name == item->baseName() )
         {
             return true;
         }
     }
     return false;
 }
 
 bool ProjectBaseItem::isProjectRoot() const
 {
     return parent()==0;
 }
 
 ProjectBuildFolderItem::ProjectBuildFolderItem(IProject* project, const Path& path, ProjectBaseItem *parent)
     : ProjectFolderItem( project, path, parent )
 {
 }
 
 ProjectBuildFolderItem::ProjectBuildFolderItem( const QString& name, ProjectBaseItem* parent )
     : ProjectFolderItem( name, parent )
 {
 
 }
 
 QString ProjectFolderItem::iconName() const
 {
     return "folder";
 }
 
 int ProjectBuildFolderItem::type() const
 {
     return ProjectBaseItem::BuildFolder;
 }
 
 QString ProjectBuildFolderItem::iconName() const
 {
     return "folder-development";
 }
 
 ProjectFileItem::ProjectFileItem( IProject* project, const Path& path, ProjectBaseItem* parent )
     : ProjectBaseItem( project, path.lastPathSegment(), parent )
 {
     setFlags(flags() | Qt::ItemIsDragEnabled);
     setPath( path );
 }
 
 ProjectFileItem::ProjectFileItem( const QString& name, ProjectBaseItem* parent )
     : ProjectBaseItem( parent->project(), name, parent )
 {
     setFlags(flags() | Qt::ItemIsDragEnabled);
     setPath( Path(parent->path(), name) );
 }
 
 ProjectFileItem::~ProjectFileItem()
 {
     if( project() && d_ptr->m_pathIndex ) {
         project()->removeFromFileSet( this );
     }
 }
 
 IndexedString ProjectFileItem::indexedPath() const
 {
     return IndexedString::fromIndex( d_ptr->m_pathIndex );
 }
 
 ProjectBaseItem::RenameStatus ProjectFileItem::rename(const QString& newName)
 {
     return d_ptr->renameFileOrFolder(this, newName);
 }
 
 QString ProjectFileItem::fileName() const
 {
     return baseName();
 }
 
 // Maximum length of a string to still consider it as a file extension which we cache
 // This has to be a slow value, so that we don't fill our file extension cache with crap
 static const int maximumCacheExtensionLength = 3;
 
 bool isNumeric(const QStringRef& str)
 {
     int len = str.length();
     if(len == 0)
         return false;
     for(int a = 0; a < len; ++a)
         if(!str.at(a).isNumber())
             return false;
     return true;
 }
 
 class IconNameCache
 {
 public:
     QString iconNameForPath(const Path& path, const QString& fileName)
     {
         // find icon name based on file extension, if possible
         QString extension;
         int extensionStart = fileName.lastIndexOf(QLatin1Char('.'));
         if( extensionStart != -1 && fileName.length() - extensionStart - 1 <= maximumCacheExtensionLength ) {
             QStringRef extRef = fileName.midRef(extensionStart + 1);
             if( isNumeric(extRef) ) {
                 // don't cache numeric extensions
                 extRef.clear();
             }
             if( !extRef.isEmpty() ) {
                 extension = extRef.toString();
                 QMutexLocker lock(&mutex);
                 QHash< QString, QString >::const_iterator it = fileExtensionToIcon.constFind( extension );
                 if( it != fileExtensionToIcon.constEnd() ) {
                     return *it;
                 }
             }
         }
 
         QMimeType mime = QMimeDatabase().mimeTypeForFile(path.lastPathSegment(), QMimeDatabase::MatchExtension); // no I/O
         QMutexLocker lock(&mutex);
         QHash< QString, QString >::const_iterator it = mimeToIcon.constFind(mime.name());
         QString iconName;
         if ( it == mimeToIcon.constEnd() ) {
             iconName = mime.iconName();
             mimeToIcon.insert(mime.name(), iconName);
         } else {
             iconName = *it;
         }
         if ( !extension.isEmpty() ) {
             fileExtensionToIcon.insert(extension, iconName);
         }
         return iconName;
     }
     QMutex mutex;
     QHash<QString, QString> mimeToIcon;
     QHash<QString, QString> fileExtensionToIcon;
 };
 
 Q_GLOBAL_STATIC(IconNameCache, s_cache);
 
 QString ProjectFileItem::iconName() const
 {
     // think of d_ptr->iconName as mutable, possible since d_ptr is not const
     if (d_ptr->iconName.isEmpty()) {
         // lazy load implementation of icon lookup
         d_ptr->iconName = s_cache->iconNameForPath( d_ptr->m_path, d_ptr->text );
         // we should always get *some* icon name back
         Q_ASSERT(!d_ptr->iconName.isEmpty());
     }
     return d_ptr->iconName;
 }
 
 void ProjectFileItem::setPath( const Path& path )
 {
     if (path == d_ptr->m_path) {
         return;
     }
 
     if( project() && d_ptr->m_pathIndex ) {
         // remove from fileset if we are in there
         project()->removeFromFileSet( this );
     }
 
     ProjectBaseItem::setPath( path );
 
     if( project() && d_ptr->m_pathIndex ) {
         // add to fileset with new path
         project()->addToFileSet( this );
     }
 
     // invalidate icon name for future lazy-loaded updated
     d_ptr->iconName.clear();
 }
 
 int ProjectFileItem::type() const
 {
     return ProjectBaseItem::File;
 }
 
 ProjectFileItem *ProjectFileItem::file() const
 {
     return const_cast<ProjectFileItem*>( this );
 }
 
 ProjectTargetItem::ProjectTargetItem( IProject* project, const QString &name, ProjectBaseItem *parent )
     : ProjectBaseItem( project, name, parent )
 {
     setFlags(flags() | Qt::ItemIsDropEnabled);
 }
 
 QString ProjectTargetItem::iconName() const
 {
     return "system-run";
 }
 
 void ProjectTargetItem::setPath( const Path& path )
 {
     // don't call base class, it calls setText with the new path's filename
     // which we do not want for target items
     d_ptr->m_path = path;
 }
 
 int ProjectTargetItem::type() const
 {
     return ProjectBaseItem::Target;
 }
 
 ProjectTargetItem *ProjectTargetItem::target() const
 {
     return const_cast<ProjectTargetItem*>( this );
 }
 
 ProjectExecutableTargetItem::ProjectExecutableTargetItem( IProject* project, const QString &name, ProjectBaseItem *parent )
     : ProjectTargetItem(project, name, parent)
 {
 }
 
 ProjectExecutableTargetItem *ProjectExecutableTargetItem::executable() const
 {
     return const_cast<ProjectExecutableTargetItem*>( this );
 }
 
 int ProjectExecutableTargetItem::type() const
 {
     return ProjectBaseItem::ExecutableTarget;
 }
 
 ProjectLibraryTargetItem::ProjectLibraryTargetItem( IProject* project, const QString &name, ProjectBaseItem *parent )
     : ProjectTargetItem(project, name, parent)
 {}
 
 int ProjectLibraryTargetItem::type() const
 {
     return ProjectBaseItem::LibraryTarget;
 }
 
 QModelIndex ProjectModel::pathToIndex(const QStringList& tofetch_) const
 {
     if(tofetch_.isEmpty())
         return QModelIndex();
     QStringList tofetch(tofetch_);
     if(tofetch.last().isEmpty())
         tofetch.takeLast();
 
     QModelIndex current=index(0,0, QModelIndex());
 
     QModelIndex ret;
     for(int a = 0; a < tofetch.size(); ++a)
     {
         const QString& currentName = tofetch[a];
 
         bool matched = false;
         QModelIndexList l = match(current, Qt::DisplayRole, currentName, -1, Qt::MatchExactly);
         foreach(const QModelIndex& idx, l) {
             //If this is not the last item, only match folders, as there may be targets and folders with the same name
             if(a == tofetch.size()-1 || itemFromIndex(idx)->folder()) {
                 ret = idx;
                 current = index(0,0, ret);
                 matched = true;
                 break;
             }
         }
         if(!matched) {
             ret = QModelIndex();
             break;
         }
     }
     Q_ASSERT(!ret.isValid() || data(ret).toString()==tofetch.last());
     return ret;
 }
 
 QStringList ProjectModel::pathFromIndex(const QModelIndex& index) const
 {
     if (!index.isValid())
         return QStringList();
 
     QModelIndex idx = index;
     QStringList list;
     do {
         QString t = data(idx, Qt::DisplayRole).toString();
         list.prepend(t);
         QModelIndex parent = idx.parent();
         idx = parent.sibling(parent.row(), index.column());
     } while (idx.isValid());
 
     return list;
 }
 
 int ProjectModel::columnCount( const QModelIndex& ) const
 {
     return 1;
 }
 
 int ProjectModel::rowCount( const QModelIndex& parent ) const
 {
     ProjectBaseItem* item = d->itemFromIndex( parent );
     return item ? item->rowCount() : 0;
 }
 
 QModelIndex ProjectModel::parent( const QModelIndex& child ) const
 {
     if( child.isValid() ) {
         ProjectBaseItem* item = static_cast<ProjectBaseItem*>( child.internalPointer() );
         return indexFromItem( item );
     }
     return QModelIndex();
 }
 
 QModelIndex ProjectModel::indexFromItem( const ProjectBaseItem* item ) const
 {
     if( item && item->d_func()->parent ) {
         return createIndex( item->row(), 0, item->d_func()->parent );
     }
     return QModelIndex();
 }
 
 ProjectBaseItem* ProjectModel::itemFromIndex( const QModelIndex& index ) const
 {
     if( index.row() >= 0 && index.column() == 0  && index.model() == this ) {
         ProjectBaseItem* parent = static_cast<ProjectBaseItem*>( index.internalPointer() );
         if( parent ) {
             return parent->child( index.row() );
         }
     }
     return 0;
 }
 
 QVariant ProjectModel::data( const QModelIndex& index, int role ) const
 {
     static const QSet<int> allowedRoles = {
         Qt::DisplayRole,
         Qt::ToolTipRole,
         Qt::DecorationRole,
         ProjectItemRole,
         ProjectRole,
         UrlRole
     };
     if( allowedRoles.contains(role) && index.isValid() ) {
         ProjectBaseItem* item = itemFromIndex( index );
         if( item ) {
             switch(role) {
                 case Qt::DecorationRole:
                     return QIcon::fromTheme(item->iconName());
                 case Qt::ToolTipRole:
                     return item->path().pathOrUrl();
                 case Qt::DisplayRole:
                     return item->text();
                 case ProjectItemRole:
                     return QVariant::fromValue<ProjectBaseItem*>(item);
                 case UrlRole:
                     return item->path().toUrl();
                 case ProjectRole:
                     return QVariant::fromValue<QObject*>(item->project());
             }
         }
     }
     return QVariant();
 }
 
 ProjectModel::ProjectModel( QObject *parent )
         : QAbstractItemModel( parent ), d( new ProjectModelPrivate( this ) )
 {
     d->rootItem = new ProjectBaseItem( 0, "", 0 );
     d->rootItem->setModel( this );
 }
 
 ProjectModel::~ProjectModel()
 {
+    d->rootItem->setModel(nullptr);
+    delete d->rootItem;
     delete d;
 }
 
 
 ProjectVisitor::ProjectVisitor()
 {
 }
 
 QModelIndex ProjectModel::index( int row, int column, const QModelIndex& parent ) const
 {
     ProjectBaseItem* parentItem = d->itemFromIndex( parent );
     if( parentItem && row >= 0 && row < parentItem->rowCount() && column == 0 ) {
         return createIndex( row, column, parentItem );
     }
     return QModelIndex();
 }
 
 void ProjectModel::appendRow( ProjectBaseItem* item )
 {
     d->rootItem->appendRow( item );
 }
 
 void ProjectModel::removeRow( int row )
 {
     d->rootItem->removeRow( row );
 }
 
 ProjectBaseItem* ProjectModel::takeRow( int row )
 {
     return d->rootItem->takeRow( row );
 }
 
 ProjectBaseItem* ProjectModel::itemAt(int row) const
 {
     return d->rootItem->child(row);
 }
 
 QList< ProjectBaseItem* > ProjectModel::topItems() const
 {
     return d->rootItem->children();
 }
 
 Qt::ItemFlags ProjectModel::flags(const QModelIndex& index) const
 {
     ProjectBaseItem* item = itemFromIndex( index );
     if(item)
         return item->flags();
     else
         return 0;
 }
 
 bool ProjectModel::insertColumns(int, int, const QModelIndex&)
 {
     // Not supported
     return false;
 }
 
 bool ProjectModel::insertRows(int, int, const QModelIndex&)
 {
     // Not supported
     return false;
 }
 
 bool ProjectModel::setData(const QModelIndex&, const QVariant&, int)
 {
     // Not supported
     return false;
 }
 
 QList<ProjectBaseItem*> ProjectModel::itemsForPath(const IndexedString& path) const
 {
     return d->pathLookupTable.values(path.index());
 }
 
 ProjectBaseItem* ProjectModel::itemForPath(const IndexedString& path) const
 {
     return d->pathLookupTable.value(path.index());
 }
 
 void ProjectVisitor::visit( ProjectModel* model )
 {
     foreach( ProjectBaseItem* item, model->topItems() )
     {
         visit( item->project() );
     }
 }
 
 void ProjectVisitor::visit ( IProject* prj )
 {
     visit( prj->projectItem() );
 }
 
 void ProjectVisitor::visit ( ProjectBuildFolderItem* folder )
 {
     foreach( ProjectFileItem* item, folder->fileList() )
     {
         visit( item );
     }
     foreach( ProjectTargetItem* item, folder->targetList() )
     {
         if( item->type() == ProjectBaseItem::LibraryTarget )
         {
             visit( dynamic_cast<ProjectLibraryTargetItem*>( item ) );
         } else if( item->type() == ProjectBaseItem::ExecutableTarget )
         {
             visit( dynamic_cast<ProjectExecutableTargetItem*>( item ) );
         }
     }
     foreach( ProjectFolderItem* item, folder->folderList() )
     {
         if( item->type() == ProjectBaseItem::BuildFolder )
         {
             visit( dynamic_cast<ProjectBuildFolderItem*>( item ) );
         } else if( item->type() == ProjectBaseItem::Folder )
         {
             visit( dynamic_cast<ProjectFolderItem*>( item ) );
         }
     }
 }
 
 void ProjectVisitor::visit ( ProjectExecutableTargetItem* exec )
 {
     foreach( ProjectFileItem* item, exec->fileList() )
     {
         visit( item );
     }
 }
 
 void ProjectVisitor::visit ( ProjectFolderItem* folder )
 {
     foreach( ProjectFileItem* item, folder->fileList() )
     {
         visit( item );
     }
     foreach( ProjectTargetItem* item, folder->targetList() )
     {
         if( item->type() == ProjectBaseItem::LibraryTarget )
         {
             visit( dynamic_cast<ProjectLibraryTargetItem*>( item ) );
         } else if( item->type() == ProjectBaseItem::ExecutableTarget )
         {
             visit( dynamic_cast<ProjectExecutableTargetItem*>( item ) );
         }
     }
     foreach( ProjectFolderItem* item, folder->folderList() )
     {
         if( item->type() == ProjectBaseItem::BuildFolder )
         {
             visit( dynamic_cast<ProjectBuildFolderItem*>( item ) );
         } else if( item->type() == ProjectBaseItem::Folder )
         {
             visit( dynamic_cast<ProjectFolderItem*>( item ) );
         }
     }
 }
 
 
 void ProjectVisitor::visit ( ProjectFileItem* )
 {
 }
 
 void ProjectVisitor::visit ( ProjectLibraryTargetItem* lib )
 {
     foreach( ProjectFileItem* item, lib->fileList() )
     {
         visit( item );
     }
 }
 
 ProjectVisitor::~ProjectVisitor()
 {
 }
 
 
 }
diff --git a/shell/launchconfigurationdialog.cpp b/shell/launchconfigurationdialog.cpp
index cccc91210..c1eeb6331 100644
--- a/shell/launchconfigurationdialog.cpp
+++ b/shell/launchconfigurationdialog.cpp
@@ -1,1027 +1,1023 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 
     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 "launchconfigurationdialog.h"
 
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QMenu>
 #include <QPushButton>
 #include <QTabWidget>
 #include <QToolButton>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include <KComboBox>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <interfaces/launchconfigurationpage.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/isession.h>
 
 #include "core.h"
 #include "runcontroller.h"
 #include "launchconfiguration.h"
 #include "debug.h"
 
 #include <interfaces/ilauncher.h>
 #include <interfaces/ilaunchmode.h>
 #include <interfaces/launchconfigurationtype.h>
 
 namespace KDevelop
 {
 
 bool launchConfigGreaterThan(KDevelop::LaunchConfigurationType* a, KDevelop::LaunchConfigurationType* b)
 {
     return a->name()>b->name();
 }
 
 //TODO: Maybe use KPageDialog instead, might make the model stuff easier and the default-size stuff as well
 LaunchConfigurationDialog::LaunchConfigurationDialog(QWidget* parent)
     : QDialog(parent)
     , currentPageChanged(false)
 {
     setWindowTitle( i18n( "Launch Configurations" ) );
 
     QWidget *mainWidget = new QWidget(this);
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(mainWidget);
 
     setupUi(mainWidget);
     mainLayout->setContentsMargins( 0, 0, 0, 0 );
     splitter->setSizes(QList<int>() << 260 << 620);
 
     addConfig->setIcon( QIcon::fromTheme(QStringLiteral("list-add")) );
     addConfig->setToolTip(i18nc("@info:tooltip", "Add a new launch configuration."));
     deleteConfig->setIcon( QIcon::fromTheme(QStringLiteral("list-remove")) );
     deleteConfig->setEnabled( false );
     deleteConfig->setToolTip(i18nc("@info:tooltip", "Delete selected launch configuration."));
 
     model = new LaunchConfigurationsModel( tree );
     tree->setModel( model );
     tree->setExpandsOnDoubleClick( true );
     tree->setSelectionBehavior( QAbstractItemView::SelectRows );
     tree->setSelectionMode( QAbstractItemView::SingleSelection );
     tree->setUniformRowHeights( true );
-    tree->setItemDelegate( new LaunchConfigurationModelDelegate() );
+    tree->setItemDelegate( new LaunchConfigurationModelDelegate(this) );
     tree->setColumnHidden(1, true);
     for(int row=0; row<model->rowCount(); row++) {
         tree->setExpanded(model->index(row, 0), true);
     }
 
     tree->setContextMenuPolicy(Qt::CustomContextMenu);
     connect( tree, &QTreeView::customContextMenuRequested, this, &LaunchConfigurationDialog::doTreeContextMenu );
     connect( deleteConfig, &QToolButton::clicked, this, &LaunchConfigurationDialog::deleteConfiguration);
     connect( model, &LaunchConfigurationsModel::dataChanged, this, &LaunchConfigurationDialog::modelChanged );
     connect( tree->selectionModel(), &QItemSelectionModel::selectionChanged, this, &LaunchConfigurationDialog::selectionChanged);
     QModelIndex idx = model->indexForConfig( Core::self()->runControllerInternal()->defaultLaunch() );
     qCDebug(SHELL) << "selecting index:" << idx;
     if( !idx.isValid() )
     {
         for( int i = 0; i < model->rowCount(); i++ )
         {
             if( model->rowCount( model->index( i, 0, QModelIndex() ) ) > 0 )
             {
                 idx = model->index( 1, 0, model->index( i, 0, QModelIndex() ) );
                 break;
             }
         }
         if( !idx.isValid() )
         {
             idx = model->index( 0, 0, QModelIndex() );
         }
     }
     tree->selectionModel()->select( QItemSelection( idx, idx ), QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows );
     tree->selectionModel()->setCurrentIndex( idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows );
 
     // Unfortunately tree->resizeColumnToContents() only looks at the top-level
     // items, instead of all open ones. Hence we're calculating it ourselves like
     // this:
     // Take the selected index, check if it has childs, if so take the first child
     // Then count the level by going up, then let the tree calculate the width
     // for the selected or its first child index and add indentation*level
     //
     // If Qt Software ever fixes resizeColumnToContents, the following line
     // can be enabled and the rest be removed
     // tree->resizeColumnToContents( 0 );
     int level = 0;
     QModelIndex widthidx = idx;
     if( model->rowCount( idx ) > 0 )
     {
         widthidx = idx.child( 0, 0 );
     }
     QModelIndex parentidx = widthidx.parent();
     while( parentidx.isValid() )
     {
         level++;
         parentidx = parentidx.parent();
     }
     // make sure the base column width is honored, e.g. when no launch configs exist
     tree->resizeColumnToContents(0);
     int width = tree->columnWidth( 0 );
     while ( widthidx.isValid() )
     {
         width = qMax( width, level*tree->indentation() + tree->indentation() + tree->sizeHintForIndex( widthidx ).width() );
         widthidx = widthidx.parent();
     }
     tree->setColumnWidth( 0, width );
 
     QMenu* m = new QMenu(this);
     QList<LaunchConfigurationType*> types = Core::self()->runController()->launchConfigurationTypes();
     std::sort(types.begin(), types.end(), launchConfigGreaterThan); //we want it in reverse order
     foreach(LaunchConfigurationType* type, types)
     {
         connect(type, &LaunchConfigurationType::signalAddLaunchConfiguration, this, &LaunchConfigurationDialog::addConfiguration);
         QMenu* suggestionsMenu = type->launcherSuggestions();
 
         if(suggestionsMenu) {
             m->addMenu(suggestionsMenu);
         }
     }
     // Simplify menu structure to get rid of 1-entry levels
     while (m->actions().count() == 1) {
         QMenu* subMenu = m->actions().at(0)->menu();
         if (subMenu && subMenu->isEnabled() && subMenu->actions().count()<5) {
             m = subMenu;
         } else {
             break;
         }
     }
     if(!m->isEmpty()) {
         QAction* separator = new QAction(m);
         separator->setSeparator(true);
         m->insertAction(m->actions().at(0), separator);
     }
 
     foreach(LaunchConfigurationType* type, types) {
         QAction* action = new QAction(type->icon(), type->name(), m);
         action->setProperty("configtype", qVariantFromValue<QObject*>(type));
         connect(action, &QAction::triggered, this, &LaunchConfigurationDialog::createEmptyLauncher);
 
         if(!m->actions().isEmpty())
             m->insertAction(m->actions().at(0), action);
         else
             m->addAction(action);
     }
     addConfig->setMenu(m);
     addConfig->setEnabled( !m->isEmpty() );
 
     messageWidget->setCloseButtonVisible( false );
     messageWidget->setMessageType( KMessageWidget::Warning );
     messageWidget->setText( i18n("No launch configurations available. (Is any of the Execute plugins loaded?)") );
     messageWidget->setVisible( m->isEmpty() );
 
     connect(debugger, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LaunchConfigurationDialog::launchModeChanged);
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &LaunchConfigurationDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &LaunchConfigurationDialog::reject);
     connect(buttonBox->button(QDialogButtonBox::Ok), &QPushButton::clicked, this, static_cast<void(LaunchConfigurationDialog::*)()>(&LaunchConfigurationDialog::saveConfig) );
     connect(buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked, this, static_cast<void(LaunchConfigurationDialog::*)()>(&LaunchConfigurationDialog::saveConfig) );
     mainLayout->addWidget(buttonBox);
 
     resize( QSize(qMax(700, sizeHint().width()), qMax(500, sizeHint().height())) );
 }
 
 void LaunchConfigurationDialog::doTreeContextMenu(QPoint point)
 {
     if ( ! tree->selectionModel()->selectedRows().isEmpty() ) {
         QModelIndex selected = tree->selectionModel()->selectedRows().first();
         if ( selected.parent().isValid() && ! selected.parent().parent().isValid() ) {
             // only display the menu if a launch config is clicked
             QMenu menu;
             QAction* rename = new QAction(QIcon::fromTheme(QStringLiteral("edit-rename")), i18n("Rename configuration"), &menu);
             QAction* delete_ = new QAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18n("Delete configuration"), &menu);
             connect(rename, &QAction::triggered, this, &LaunchConfigurationDialog::renameSelected);
             connect(delete_, &QAction::triggered, this, &LaunchConfigurationDialog::deleteConfiguration);
             menu.addAction(rename);
             menu.addAction(delete_);
             menu.exec(tree->mapToGlobal(point));
         }
     }
 }
 
 void LaunchConfigurationDialog::renameSelected()
 {
     if( !tree->selectionModel()->selectedRows().isEmpty() )
     {
         QModelIndex parent = tree->selectionModel()->selectedRows().first();
         if( parent.parent().isValid() )
         {
             parent = parent.parent();
         }
         QModelIndex index = model->index(tree->selectionModel()->selectedRows().first().row(), 0, parent);
         tree->edit( index );
     }
 }
 
 QSize LaunchConfigurationDialog::sizeHint() const
 {
     QSize s = QDialog::sizeHint();
     return s.expandedTo(QSize(880, 520));
 }
 
 void LaunchConfigurationDialog::createEmptyLauncher()
 {
     QAction* action = qobject_cast<QAction*>(sender());
     Q_ASSERT(action);
 
     LaunchConfigurationType* type = qobject_cast<LaunchConfigurationType*>(action->property("configtype").value<QObject*>());
     Q_ASSERT(type);
 
     IProject* p = model->projectForIndex(tree->currentIndex());
     QPair< QString, QString > launcher( type->launchers().at( 0 )->supportedModes().at(0), type->launchers().at( 0 )->id() );
     ILaunchConfiguration* l = ICore::self()->runController()->createLaunchConfiguration(type, launcher, p);
     addConfiguration(l);
 }
 
 void LaunchConfigurationDialog::selectionChanged(QItemSelection selected, QItemSelection deselected )
 {
     if( !deselected.indexes().isEmpty() )
     {
         LaunchConfiguration* l = model->configForIndex( deselected.indexes().first() );
         if( l )
         {
             disconnect(l, &LaunchConfiguration::nameChanged, this,  &LaunchConfigurationDialog::updateNameLabel);
             if( currentPageChanged )
             {
                 if( KMessageBox::questionYesNo( this, i18n("Selected Launch Configuration has unsaved changes. Do you want to save it?"), i18n("Unsaved Changes") ) == KMessageBox::Yes )
                 {
                     saveConfig( deselected.indexes().first() );
                 } else {
                     LaunchConfigPagesContainer* tab = qobject_cast<LaunchConfigPagesContainer*>( stack->currentWidget() );
                     tab->setLaunchConfiguration( l );
                     buttonBox->button(QDialogButtonBox::Apply)->setEnabled( false );
                     currentPageChanged = false;
                 }
             }
         }
     }
     updateNameLabel(0);
 
     for( int i = 1; i < stack->count(); i++ )
     {
         QWidget* w = stack->widget(i);
         stack->removeWidget(w);
         delete w;
     }
 
     debugger->clear();
     if( !selected.indexes().isEmpty() )
     {
         QModelIndex idx = selected.indexes().first();
         LaunchConfiguration* l = model->configForIndex( idx );
         ILaunchMode* lm = model->modeForIndex( idx );
 
         if( l )
         {
             updateNameLabel( l );
             tree->expand( model->indexForConfig( l ) );
             connect( l, &LaunchConfiguration::nameChanged, this, &LaunchConfigurationDialog::updateNameLabel );
             if( lm )
             {
                 bool b = debugger->blockSignals(true);
                 QList<ILauncher*> launchers = l->type()->launchers();
                 for( QList<ILauncher*>::const_iterator it = launchers.constBegin(); it != launchers.constEnd(); it++ )
                 {
                     if( ((*it)->supportedModes().contains( lm->id() ) ) ) {
                         debugger->addItem( (*it)->name(), (*it)->id() );
                     }
                 }
                 debugger->blockSignals(b);
 
                 debugger->setVisible(debugger->count()>0);
                 debugLabel->setVisible(debugger->count()>0);
 
                 QVariant currentLaunchMode = idx.sibling(idx.row(), 1).data(Qt::EditRole);
                 debugger->setCurrentIndex(debugger->findData(currentLaunchMode));
 
                 ILauncher* launcher = l->type()->launcherForId( currentLaunchMode.toString() );
                 if( launcher )
                 {
                     LaunchConfigPagesContainer* tab = launcherWidgets.value( launcher );
                     if(!tab)
                     {
                         QList<KDevelop::LaunchConfigurationPageFactory*> pages = launcher->configPages();
                         if(!pages.isEmpty()) {
                             tab = new LaunchConfigPagesContainer( launcher->configPages(), stack );
                             connect( tab, &LaunchConfigPagesContainer::changed, this, &LaunchConfigurationDialog::pageChanged );
                             stack->addWidget( tab );
                         }
                     }
 
                     if(tab) {
                         tab->setLaunchConfiguration( l );
                         stack->setCurrentWidget( tab );
                     } else {
                         QLabel* label = new QLabel(i18nc("%1 is a launcher name",
                                                          "No configuration is needed for '%1'",
                                                          launcher->name()), stack);
                         label->setAlignment(Qt::AlignCenter);
                         QFont font = label->font();
                         font.setItalic(true);
                         label->setFont(font);
                         stack->addWidget(label);
                         stack->setCurrentWidget(label);
                     }
 
                     updateNameLabel( l );
                     addConfig->setEnabled( false );
                     deleteConfig->setEnabled( false );
                 } else
                 {
                     addConfig->setEnabled( false );
                     deleteConfig->setEnabled( false );
                     stack->setCurrentIndex( 0 );
                 }
             } else
             {
                 //TODO: enable removal button
                 LaunchConfigurationType* type = l->type();
                 LaunchConfigPagesContainer* tab = typeWidgets.value( type );
                 if( !tab )
                 {
                     tab = new LaunchConfigPagesContainer( type->configPages(), stack );
                     connect( tab, &LaunchConfigPagesContainer::changed, this, &LaunchConfigurationDialog::pageChanged );
                     stack->addWidget( tab );
                 }
                 qCDebug(SHELL) << "created pages, setting config up";
                 tab->setLaunchConfiguration( l );
                 stack->setCurrentWidget( tab );
 
                 addConfig->setEnabled( addConfig->menu() && !addConfig->menu()->isEmpty() );
                 deleteConfig->setEnabled( true );
                 debugger->setVisible( false );
                 debugLabel->setVisible( false );
             }
         } else
         {
             addConfig->setEnabled( addConfig->menu() && !addConfig->menu()->isEmpty() );
             deleteConfig->setEnabled( false );
             stack->setCurrentIndex( 0 );
             QLabel* l = new QLabel(i18n("<i>Select a configuration to edit from the left,<br>"
                                         "or click the \"Add New\" button to add a new one.</i>"), stack);
             l->setAlignment(Qt::AlignCenter);
             stack->addWidget(l);
             stack->setCurrentWidget(l);
             debugger->setVisible( false );
             debugLabel->setVisible( false );
         }
     } else
     {
         debugger->setVisible( false );
         debugLabel->setVisible( false );
         addConfig->setEnabled( false );
         deleteConfig->setEnabled( false );
         stack->setCurrentIndex( 0 );
     }
 }
 
 void LaunchConfigurationDialog::saveConfig( const QModelIndex& idx )
 {
     Q_UNUSED( idx );
     LaunchConfigPagesContainer* tab = qobject_cast<LaunchConfigPagesContainer*>( stack->currentWidget() );
     if( tab )
     {
         tab->save();
         buttonBox->button(QDialogButtonBox::Apply)->setEnabled( false );
         currentPageChanged = false;
     }
 }
 
 void LaunchConfigurationDialog::saveConfig()
 {
     if( !tree->selectionModel()->selectedRows().isEmpty() )
     {
         saveConfig( tree->selectionModel()->selectedRows().first() );
     }
 }
 
 
 void LaunchConfigurationDialog::pageChanged()
 {
     currentPageChanged = true;
     buttonBox->button(QDialogButtonBox::Apply)->setEnabled( true );
 }
 
 void LaunchConfigurationDialog::modelChanged(QModelIndex topLeft, QModelIndex bottomRight)
 {
     if (tree->selectionModel())
     {
         QModelIndex index = tree->selectionModel()->selectedRows().first();
         if (index.row() >= topLeft.row() && index.row() <= bottomRight.row() && bottomRight.column() == 1)
             selectionChanged(tree->selectionModel()->selection(), tree->selectionModel()->selection());
     }
 }
 
 void LaunchConfigurationDialog::deleteConfiguration()
 {
     if( !tree->selectionModel()->selectedRows().isEmpty() )
     {
         model->deleteConfiguration( tree->selectionModel()->selectedRows().first() );
         tree->resizeColumnToContents( 0 );
     }
 }
 
 void LaunchConfigurationDialog::updateNameLabel( LaunchConfiguration* l )
 {
     if( l )
     {
         configName->setText( i18n("Editing %2: <b>%1</b>", l->name(), l->type()->name() ) );
     } else
     {
         configName->clear();
     }
 }
 
 void LaunchConfigurationDialog::createConfiguration()
 {
     if( !tree->selectionModel()->selectedRows().isEmpty() )
     {
         QModelIndex idx = tree->selectionModel()->selectedRows().first();
         if( idx.parent().isValid() )
         {
             idx = idx.parent();
         }
         model->createConfiguration( idx );
         QModelIndex newindex = model->index( model->rowCount( idx ) - 1, 0, idx );
         tree->selectionModel()->select( newindex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows );
         tree->selectionModel()->setCurrentIndex( newindex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows );
         tree->edit( newindex );
         tree->resizeColumnToContents( 0 );
     }
 }
 
 void LaunchConfigurationDialog::addConfiguration(ILaunchConfiguration* _launch)
 {
     LaunchConfiguration* launch = dynamic_cast<LaunchConfiguration*>(_launch);
     Q_ASSERT(launch);
     int row = launch->project() ? model->findItemForProject(launch->project())->row : 0;
     QModelIndex idx  = model->index(row, 0);
 
     model->addConfiguration(launch, idx);
 
     QModelIndex newindex = model->index( model->rowCount( idx ) - 1, 0, idx );
     tree->selectionModel()->select( newindex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows );
     tree->selectionModel()->setCurrentIndex( newindex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows );
     tree->edit( newindex );
     tree->resizeColumnToContents( 0 );
 }
 
 LaunchConfigurationsModel::LaunchConfigurationsModel(QObject* parent): QAbstractItemModel(parent)
 {
     GenericPageItem* global = new GenericPageItem;
     global->text = i18n("Global");
     global->row = 0;
     topItems << global;
     foreach( IProject* p, Core::self()->projectController()->projects() )
     {
         ProjectItem* t = new ProjectItem;
         t->project = p;
         t->row = topItems.count();
         topItems << t;
     }
     foreach( LaunchConfiguration* l, Core::self()->runControllerInternal()->launchConfigurationsInternal() )
     {
         addItemForLaunchConfig( l );
     }
 }
 
 void LaunchConfigurationsModel::addItemForLaunchConfig( LaunchConfiguration* l )
 {
     LaunchItem* t = new LaunchItem;
     t->launch = l;
     TreeItem* parent;
     if( l->project() ) {
         parent = findItemForProject( l->project() );
     } else {
         parent = topItems.at(0);
     }
     t->parent = parent;
     t->row = parent->children.count();
     parent->children.append( t );
     addLaunchModeItemsForLaunchConfig ( t );
 }
 
 void LaunchConfigurationsModel::addLaunchModeItemsForLaunchConfig ( LaunchItem* t )
 {
     QList<TreeItem*> items;
     QSet<QString> modes;
     foreach( ILauncher* launcher, t->launch->type()->launchers() )
     {
         foreach( const QString& mode, launcher->supportedModes() )
         {
             if( !modes.contains( mode ) && launcher->configPages().count() > 0 )
             {
                 modes.insert( mode );
                 LaunchModeItem* lmi = new LaunchModeItem;
                 lmi->mode = Core::self()->runController()->launchModeForId( mode );
                 lmi->parent = t;
                 lmi->row = t->children.count();
                 items.append( lmi );
             }
         }
     }
     if( !items.isEmpty() )
     {
         QModelIndex p = indexForConfig( t->launch );
         beginInsertRows( p, t->children.count(), t->children.count() + items.count() - 1  );
         t->children.append( items );
         endInsertRows();
     }
 }
 
 LaunchConfigurationsModel::ProjectItem* LaunchConfigurationsModel::findItemForProject( IProject* p )
 {
     foreach( TreeItem* t, topItems )
     {
         ProjectItem* pi = dynamic_cast<ProjectItem*>( t );
         if( pi && pi->project == p )
         {
             return pi;
         }
     }
     Q_ASSERT(false);
     return 0;
 }
 
 int LaunchConfigurationsModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED( parent );
     return 2;
 }
 
 QVariant LaunchConfigurationsModel::data(const QModelIndex& index, int role) const
 {
     if( index.isValid() && index.column() >= 0 && index.column() < 2 )
     {
         TreeItem* t = static_cast<TreeItem*>( index.internalPointer() );
         switch( role )
         {
             case Qt::DisplayRole:
             {
                 LaunchItem* li = dynamic_cast<LaunchItem*>( t );
                 if( li )
                 {
                     if( index.column() == 0 )
                     {
                         return li->launch->name();
                     } else if( index.column() == 1 )
                     {
                         return li->launch->type()->name();
                     }
                 }
                 ProjectItem* pi = dynamic_cast<ProjectItem*>( t );
                 if( pi && index.column() == 0 )
                 {
                     return pi->project->name();
                 }
                 GenericPageItem* gpi = dynamic_cast<GenericPageItem*>( t );
                 if( gpi && index.column() == 0 )
                 {
                     return gpi->text;
                 }
                 LaunchModeItem* lmi = dynamic_cast<LaunchModeItem*>( t );
                 if( lmi )
                 {
                     if( index.column() == 0 )
                     {
                         return lmi->mode->name();
                     } else if( index.column() == 1 )
                     {
                         LaunchConfiguration* l = configForIndex( index );
                         return l->type()->launcherForId( l->launcherForMode( lmi->mode->id() ) )->name();
                     }
                 }
                 break;
             }
             case Qt::DecorationRole:
             {
                 LaunchItem* li = dynamic_cast<LaunchItem*>( t );
                 if( index.column() == 0 && li )
                 {
                     return li->launch->type()->icon();
                 }
                 LaunchModeItem* lmi = dynamic_cast<LaunchModeItem*>( t );
                 if( lmi && index.column() == 0 )
                 {
                     return lmi->mode->icon();
                 }
                 if ( index.column() == 0 && !index.parent().isValid() ) {
                     if (index.row() == 0) {
                         // global item
                         return QIcon::fromTheme(QStringLiteral("folder"));
                     } else {
                         // project item
                         return QIcon::fromTheme(QStringLiteral("folder-development"));
                     }
                 }
             }
             case Qt::EditRole:
             {
                 LaunchItem* li = dynamic_cast<LaunchItem*>( t );
                 if( li )
                 {
                     if( index.column() == 0 )
                     {
                         return li->launch->name();
                     } else if ( index.column() == 1 )
                     {
                         return li->launch->type()->id();
                     }
                 }
                 LaunchModeItem* lmi = dynamic_cast<LaunchModeItem*>( t );
                 if( lmi && index.column() == 1  )
                 {
                     return configForIndex( index )->launcherForMode( lmi->mode->id() );
                 }
                 break;
             }
             default:
                 break;
         }
     }
     return QVariant();
 }
 
 QModelIndex LaunchConfigurationsModel::index(int row, int column, const QModelIndex& parent) const
 {
     if( !hasIndex( row, column, parent ) )
         return QModelIndex();
     TreeItem* tree;
 
     if( !parent.isValid() )
     {
         tree = topItems.at( row );
     } else
     {
         TreeItem* t = static_cast<TreeItem*>( parent.internalPointer() );
         tree = t->children.at( row );
     }
     if( tree )
     {
         return createIndex( row, column, tree );
     }
     return QModelIndex();
 }
 
 QModelIndex LaunchConfigurationsModel::parent(const QModelIndex& child) const
 {
     if( child.isValid()  )
     {
         TreeItem* t = static_cast<TreeItem*>( child.internalPointer() );
         if( t->parent )
         {
             return createIndex( t->parent->row, 0, t->parent );
         }
     }
     return QModelIndex();
 }
 
 int LaunchConfigurationsModel::rowCount(const QModelIndex& parent) const
 {
     if( parent.column() > 0 )
         return 0;
     if( parent.isValid() )
     {
         TreeItem* t = static_cast<TreeItem*>( parent.internalPointer() );
         return t->children.count();
     } else
     {
         return topItems.count();
     }
     return 0;
 }
 
 QVariant LaunchConfigurationsModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if( orientation == Qt::Horizontal && role == Qt::DisplayRole )
     {
         if( section == 0 )
         {
             return i18nc("Name of the Launch Configurations", "Name");
         } else if( section == 1 )
         {
             return i18nc("The type of the Launch Configurations (i.e. Python Application, C++ Application)", "Type");
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags LaunchConfigurationsModel::flags(const QModelIndex& index) const
 {
     if( index.isValid() && index.column() >= 0
         && index.column() < columnCount( QModelIndex() ) )
     {
         TreeItem* t = static_cast<TreeItem*>( index.internalPointer() );
         if( t && ( dynamic_cast<LaunchItem*>( t ) || ( dynamic_cast<LaunchModeItem*>( t ) && index.column() == 1 ) ) )
         {
             return Qt::ItemFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
         } else if( t )
         {
             return Qt::ItemFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
         }
     }
     return Qt::NoItemFlags;
 }
 
 bool LaunchConfigurationsModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
     if( index.isValid() && index.parent().isValid() && role == Qt::EditRole )
     {
         if( index.row() >= 0 && index.row() < rowCount( index.parent() ) )
         {
             LaunchItem* t = dynamic_cast<LaunchItem*>( static_cast<TreeItem*>( index.internalPointer() ) );
             if( t )
             {
                 if( index.column() == 0 )
                 {
                     t->launch->setName( value.toString() );
                 } else if( index.column() == 1 )
                 {
                     if (t->launch->type()->id() != value.toString()) {
                         t->launch->setType( value.toString() );
                         QModelIndex p = indexForConfig(t->launch);
                         qCDebug(SHELL) << data(p);
                         beginRemoveRows( p, 0, t->children.count() );
                         qDeleteAll( t->children );
                         t->children.clear();
                         endRemoveRows();
                         addLaunchModeItemsForLaunchConfig( t );
                     }
                 }
                 emit dataChanged(index, index);
                 return true;
             }
             LaunchModeItem* lmi = dynamic_cast<LaunchModeItem*>( static_cast<TreeItem*>( index.internalPointer() ) );
             if( lmi )
             {
                 if( index.column() == 1 && index.data(Qt::EditRole)!=value)
                 {
                     LaunchConfiguration* l = configForIndex( index );
                     l->setLauncherForMode( lmi->mode->id(), value.toString() );
                     emit dataChanged(index, index);
                     return true;
                 }
             }
         }
     }
     return false;
 }
 
 ILaunchMode* LaunchConfigurationsModel::modeForIndex( const QModelIndex& idx ) const
 {
     if( idx.isValid() )
     {
         LaunchModeItem* item = dynamic_cast<LaunchModeItem*>( static_cast<TreeItem*>( idx.internalPointer() ) );
         if( item )
         {
             return item->mode;
         }
     }
     return 0;
 }
 
 LaunchConfiguration* LaunchConfigurationsModel::configForIndex(const QModelIndex& idx ) const
 {
     if( idx.isValid() )
     {
         LaunchItem* item = dynamic_cast<LaunchItem*>( static_cast<TreeItem*>( idx.internalPointer() ) );
         if( item )
         {
             return item->launch;
         }
         LaunchModeItem* lmitem = dynamic_cast<LaunchModeItem*>( static_cast<TreeItem*>( idx.internalPointer() ) );
         if( lmitem )
         {
             return dynamic_cast<LaunchItem*>( lmitem->parent )->launch;
         }
     }
     return 0;
 }
 
 QModelIndex LaunchConfigurationsModel::indexForConfig( LaunchConfiguration* l ) const
 {
     if( l )
     {
         TreeItem* tparent = topItems.at( 0 );
         if( l->project() )
         {
             foreach( TreeItem* t, topItems )
             {
                 ProjectItem* pi = dynamic_cast<ProjectItem*>( t );
                 if( pi && pi->project == l->project() )
                 {
                     tparent = t;
                     break;
                 }
             }
         }
 
         if( tparent )
         {
             foreach( TreeItem* c, tparent->children )
             {
                 LaunchItem* li = dynamic_cast<LaunchItem*>( c );
                 if( li->launch && li->launch == l )
                 {
                     return index( c->row, 0, index( tparent->row, 0, QModelIndex() ) );
                 }
             }
         }
     }
     return QModelIndex();
 }
 
 
 void LaunchConfigurationsModel::deleteConfiguration( const QModelIndex& index )
 {
     LaunchItem* t = dynamic_cast<LaunchItem*>( static_cast<TreeItem*>( index.internalPointer() ) );
     if( !t )
         return;
     beginRemoveRows( parent( index ), index.row(), index.row() );
     t->parent->children.removeAll( t );
     Core::self()->runControllerInternal()->removeLaunchConfiguration( t->launch );
     endRemoveRows();
 }
 
 void LaunchConfigurationsModel::createConfiguration(const QModelIndex& parent )
 {
     if(!Core::self()->runController()->launchConfigurationTypes().isEmpty())
     {
         TreeItem* t = static_cast<TreeItem*>( parent.internalPointer() );
         ProjectItem* ti = dynamic_cast<ProjectItem*>( t );
 
         LaunchConfigurationType* type = Core::self()->runController()->launchConfigurationTypes().at(0);
         QPair<QString,QString> launcher = qMakePair( type->launchers().at( 0 )->supportedModes().at(0), type->launchers().at( 0 )->id() );
         IProject* p = ( ti ? ti->project : 0 );
         ILaunchConfiguration* l = Core::self()->runController()->createLaunchConfiguration( type, launcher, p );
 
         addConfiguration(l, parent);
     }
 }
 
 void LaunchConfigurationsModel::addConfiguration(ILaunchConfiguration* l, const QModelIndex& parent)
 {
     if( parent.isValid() )
     {
         beginInsertRows( parent, rowCount( parent ), rowCount( parent ) );
         addItemForLaunchConfig( dynamic_cast<LaunchConfiguration*>( l ) );
         endInsertRows();
     }
     else
     {
         delete l;
         Q_ASSERT(false && "could not add the configuration");
     }
 }
 
 IProject* LaunchConfigurationsModel::projectForIndex(const QModelIndex& idx)
 {
     if(idx.parent().isValid()) {
         return projectForIndex(idx.parent());
     } else {
         const ProjectItem* item = dynamic_cast<const ProjectItem*>(topItems[idx.row()]);
         return item ? item->project : 0;
     }
 }
 
 LaunchConfigPagesContainer::LaunchConfigPagesContainer( const QList<LaunchConfigurationPageFactory*>& factories, QWidget* parent )
     : QWidget(parent)
 {
     setLayout( new QVBoxLayout( this ) );
     layout()->setContentsMargins( 0, 0, 0, 0 );
     QWidget* parentwidget = this;
     QTabWidget* tab = 0;
     if( factories.count() > 1 )
     {
         tab = new QTabWidget( this );
         parentwidget = tab;
         layout()->addWidget( tab );
     }
     foreach( LaunchConfigurationPageFactory* fac, factories )
     {
         LaunchConfigurationPage* page = fac->createWidget( parentwidget );
         if ( page->layout() ) {
             page->layout()->setContentsMargins( 0, 0, 0, 0 );
         }
         pages.append( page );
         connect( page, &LaunchConfigurationPage::changed, this, &LaunchConfigPagesContainer::changed );
         if( tab ) {
             tab->addTab( page, page->icon(), page->title() );
         } else
         {
             layout()->addWidget( page );
         }
     }
 }
 
 void LaunchConfigPagesContainer::setLaunchConfiguration( KDevelop::LaunchConfiguration* l )
 {
     config = l;
     foreach( LaunchConfigurationPage* p, pages )
     {
         p->loadFromConfiguration( config->config(), config->project() );
     }
 }
 
 void LaunchConfigPagesContainer::save()
 {
     foreach( LaunchConfigurationPage* p, pages )
     {
         p->saveToConfiguration( config->config() );
     }
     config->config().sync();
 }
 
 
 QWidget* LaunchConfigurationModelDelegate::createEditor ( QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index ) const
 {
     const LaunchConfigurationsModel* model = dynamic_cast<const LaunchConfigurationsModel*>( index.model() );
     ILaunchMode* mode = model->modeForIndex( index );
     LaunchConfiguration* config = model->configForIndex( index );
     if( index.column() == 1 && mode && config )
     {
         KComboBox* box = new KComboBox( parent );
         QList<ILauncher*> launchers = config->type()->launchers();
         for( QList<ILauncher*>::const_iterator it = launchers.constBegin(); it != launchers.constEnd(); it++ )
         {
             if( ((*it)->supportedModes().contains( mode->id() ) ) )
             {
                 box->addItem( (*it)->name(), (*it)->id() );
             }
         }
         return box;
     } else if( !mode && config && index.column() == 1 )
     {
         KComboBox* box = new KComboBox( parent );
         const QList<LaunchConfigurationType*> types = Core::self()->runController()->launchConfigurationTypes();
         for( QList<LaunchConfigurationType*>::const_iterator it = types.begin(); it != types.end(); it++ )
         {
             box->addItem( (*it)->name(), (*it)->id() );
         }
         return box;
     }
     return QStyledItemDelegate::createEditor ( parent, option, index );
 }
 
-LaunchConfigurationModelDelegate::LaunchConfigurationModelDelegate()
-{
-}
-
 void LaunchConfigurationModelDelegate::setEditorData ( QWidget* editor, const QModelIndex& index ) const
 {
     const LaunchConfigurationsModel* model = dynamic_cast<const LaunchConfigurationsModel*>( index.model() );
     LaunchConfiguration* config = model->configForIndex( index );
     if( index.column() == 1 && config )
     {
         KComboBox* box = qobject_cast<KComboBox*>( editor );
         box->setCurrentIndex( box->findData( index.data( Qt::EditRole ) ) );
     }
     else
     {
         QStyledItemDelegate::setEditorData ( editor, index );
     }
 }
 
 void LaunchConfigurationModelDelegate::setModelData ( QWidget* editor, QAbstractItemModel* model, const QModelIndex& index ) const
 {
     LaunchConfigurationsModel* lmodel = dynamic_cast<LaunchConfigurationsModel*>( model );
     LaunchConfiguration* config = lmodel->configForIndex( index );
     if( index.column() == 1 && config )
     {
         KComboBox* box = qobject_cast<KComboBox*>( editor );
         lmodel->setData( index, box->itemData( box->currentIndex() ) );
     }
     else
     {
         QStyledItemDelegate::setModelData ( editor, model, index );
     }
 }
 
 void LaunchConfigurationDialog::launchModeChanged(int item)
 {
     QModelIndex index = tree->currentIndex();
     if(debugger->isVisible() && item>=0)
         tree->model()->setData(index.sibling(index.row(), 1), debugger->itemData(item), Qt::EditRole);
 }
 
 }
 
diff --git a/shell/launchconfigurationdialog.h b/shell/launchconfigurationdialog.h
index 937222651..cb269b229 100644
--- a/shell/launchconfigurationdialog.h
+++ b/shell/launchconfigurationdialog.h
@@ -1,167 +1,168 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 
     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.
 */
 
 #ifndef KDEVPLATFORM_LAUNCHCONFIGURATIONDIALOG_H
 #define KDEVPLATFORM_LAUNCHCONFIGURATIONDIALOG_H
 
 #include <QAbstractItemModel>
 #include <QDialog>
 #include <QList>
 #include <QMap>
 #include <QStyledItemDelegate>
 
 #include "ui_launchconfigurationdialog.h"
 
 class QItemSelection;
 
 namespace Ui
 {
 class LaunchConfigTypePage;
 }
 
 namespace KDevelop
 {
 class ILauncher;
 class LaunchConfigurationPageFactory;
 class ILaunchMode;
 
 class LaunchConfigurationType;
 class LaunchConfiguration;
 class LaunchConfigurationPage;
 class ILaunchConfiguration;
 class IProject;
 
 class LaunchConfigurationModelDelegate : public QStyledItemDelegate
 {
 Q_OBJECT
 public:
-    LaunchConfigurationModelDelegate();
+    using QStyledItemDelegate::QStyledItemDelegate;
+
     QWidget* createEditor ( QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index ) const override;
     void setEditorData ( QWidget* editor, const QModelIndex& index ) const override;
     void setModelData ( QWidget* editor, QAbstractItemModel* model, const QModelIndex& index ) const override;
 };
 
 
 class LaunchConfigurationsModel : public QAbstractItemModel
 {
 Q_OBJECT
 public:
     explicit LaunchConfigurationsModel(QObject* parent = 0);
     int columnCount(const QModelIndex& parent = QModelIndex()) const override;
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex& child) const override;
     int rowCount(const QModelIndex& parent = QModelIndex()) const override;
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     Qt::ItemFlags flags(const QModelIndex& index) const override;
     bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
     void createConfiguration( const QModelIndex& );
     void deleteConfiguration( const QModelIndex& index );
     LaunchConfiguration* configForIndex( const QModelIndex& ) const;
     ILaunchMode* modeForIndex( const QModelIndex& idx ) const;
     QModelIndex indexForConfig( LaunchConfiguration* ) const;
     void addConfiguration(KDevelop::ILaunchConfiguration* launch, const QModelIndex& idx);
     KDevelop::IProject* projectForIndex(const QModelIndex& idx);
 
 private:
     class TreeItem
     {
     public:
         TreeItem() : parent(0) {}
         virtual ~TreeItem() {}
         TreeItem* parent;
         int row;
         QList<TreeItem*> children;
     };
     class ProjectItem : public TreeItem
     {
     public:
         IProject* project;
     };
     class LaunchItem : public TreeItem
     {
     public:
         LaunchConfiguration* launch;
     };
     class LaunchModeItem : public TreeItem
     {
     public:
         ILaunchMode* mode;
     };
     class GenericPageItem : public TreeItem
     {
     public:
         QString text;
     };
     void addItemForLaunchConfig( LaunchConfiguration* l );
     void addLaunchModeItemsForLaunchConfig ( KDevelop::LaunchConfigurationsModel::LaunchItem* l );
     QList<TreeItem*> topItems;
 
 public:
     ProjectItem* findItemForProject( IProject* );
 };
 
 class LaunchConfigPagesContainer : public QWidget
 {
 Q_OBJECT
 public:
     explicit LaunchConfigPagesContainer( const QList<LaunchConfigurationPageFactory*> &, QWidget* parent = 0 );
     void setLaunchConfiguration( LaunchConfiguration* );
     void save();
 signals:
     void changed();
 private:
     LaunchConfiguration* config;
     QList<LaunchConfigurationPage*> pages;
 };
 
 class LaunchConfigurationDialog : public QDialog, public Ui::LaunchConfigurationDialog
 {
 Q_OBJECT
 public:
     explicit LaunchConfigurationDialog(QWidget* parent = 0 );
     QSize sizeHint() const override;
 
 private slots:
     void deleteConfiguration();
     void createConfiguration();
     void addConfiguration(KDevelop::ILaunchConfiguration*);
     void selectionChanged(QItemSelection,QItemSelection);
     void modelChanged(QModelIndex,QModelIndex);
     void pageChanged();
     void saveConfig();
     void updateNameLabel( LaunchConfiguration* l );
     void createEmptyLauncher();
     void launchModeChanged(int index);
 
 private:
     void saveConfig( const QModelIndex& );
     LaunchConfigurationsModel* model;
     QMap<LaunchConfigurationType*, LaunchConfigPagesContainer*> typeWidgets;
     QMap<ILauncher*, LaunchConfigPagesContainer*> launcherWidgets;
     bool currentPageChanged;
 private slots:
     void doTreeContextMenu(QPoint point);
     void renameSelected();
 };
 
 }
 
 #endif