diff --git a/documentation/documentationview.cpp b/documentation/documentationview.cpp
index 9827fe922e..f40fa8c979 100644
--- a/documentation/documentationview.cpp
+++ b/documentation/documentationview.cpp
@@ -1,373 +1,380 @@
 /*
    Copyright 2009 Aleix Pol Gonzalez <aleixpol@kde.org>
    Copyright 2010 Benjamin Port <port.benjamin@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 version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "documentationview.h"
 
 #include <QAction>
 #include <QIcon>
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QComboBox>
 #include <QTextEdit>
 #include <QCompleter>
 #include <QLayout>
 #include <QTextBrowser>
 #include <QAbstractItemView>
 
 #include <QLineEdit>
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentationprovider.h>
 #include <interfaces/idocumentationproviderprovider.h>
 #include <interfaces/idocumentationcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include "documentationfindwidget.h"
 #include "debug.h"
 
 Q_LOGGING_CATEGORY(DOCUMENTATION, "kdevplatform.documentation")
 
 
 using namespace KDevelop;
 
 DocumentationView::DocumentationView(QWidget* parent, ProvidersModel* model)
     : QWidget(parent), mProvidersModel(model)
 {
     setWindowIcon(QIcon::fromTheme(QStringLiteral("documentation"), windowIcon()));
     setWindowTitle(i18n("Documentation"));
 
     setLayout(new QVBoxLayout(this));
     layout()->setMargin(0);
     layout()->setSpacing(0);
 
     //TODO: clean this up, simply use addAction as that will create a toolbar automatically
     //      use custom QAction's with createWidget for mProviders and mIdentifiers
     mActions = new KToolBar(this);
     // set window title so the QAction from QToolBar::toggleViewAction gets a proper name set
     mActions->setWindowTitle(i18n("Documentation Tool Bar"));
     mActions->setToolButtonStyle(Qt::ToolButtonIconOnly);
     int iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize);
     mActions->setIconSize(QSize(iconSize, iconSize));
 
     mFindDoc = new DocumentationFindWidget;
     mFindDoc->hide();
 
     mBack = mActions->addAction(QIcon::fromTheme(QStringLiteral("go-previous")), i18n("Back"));
     mForward = mActions->addAction(QIcon::fromTheme(QStringLiteral("go-next")), i18n("Forward"));
     mFind = mActions->addAction(QIcon::fromTheme(QStringLiteral("edit-find")), i18n("Find"), mFindDoc, SLOT(startSearch()));
     mActions->addSeparator();
     mActions->addAction(QIcon::fromTheme(QStringLiteral("go-home")), i18n("Home"), this, SLOT(showHome()));
     mProviders = new QComboBox(mActions);
 
     mIdentifiers = new QLineEdit(mActions);
     mIdentifiers->setClearButtonEnabled(true);
     mIdentifiers->setPlaceholderText(i18n("Search..."));
     mIdentifiers->setCompleter(new QCompleter(mIdentifiers));
 //     mIdentifiers->completer()->setCompletionMode(QCompleter::UnfilteredPopupCompletion);
     mIdentifiers->completer()->setCaseSensitivity(Qt::CaseInsensitive);
 
     /* vertical size policy should be left to the style. */
     mIdentifiers->setSizePolicy(QSizePolicy::Expanding, mIdentifiers->sizePolicy().verticalPolicy());
     connect(mIdentifiers->completer(), static_cast<void(QCompleter::*)(const QModelIndex&)>(&QCompleter::activated),
             this, &DocumentationView::changedSelection);
     connect(mIdentifiers, &QLineEdit::returnPressed, this, &DocumentationView::returnPressed);
 
     QWidget::setTabOrder(mProviders, mIdentifiers);
     mActions->addWidget(mProviders);
     mActions->addWidget(mIdentifiers);
 
     mBack->setEnabled(false);
     mForward->setEnabled(false);
     connect(mBack, &QAction::triggered, this, &DocumentationView::browseBack);
     connect(mForward, &QAction::triggered, this, &DocumentationView::browseForward);
     mCurrent = mHistory.end();
 
     layout()->addWidget(mActions);
     layout()->addWidget(new QWidget(this));
     layout()->addWidget(mFindDoc);
 
     setFocusProxy(mIdentifiers);
 
     QMetaObject::invokeMethod(this, "initialize", Qt::QueuedConnection);
 }
 
 void DocumentationView::initialize()
 {
     mProviders->setModel(mProvidersModel);
     connect(mProviders, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, &DocumentationView::changedProvider);
     foreach (IDocumentationProvider* p, mProvidersModel->providers()) {
         // can't use new signal/slot syntax here, IDocumentation is not a QObject
         connect(dynamic_cast<QObject*>(p), SIGNAL(addHistory(KDevelop::IDocumentation::Ptr)),
                 this, SLOT(addHistory(KDevelop::IDocumentation::Ptr)));
     }
     connect(mProvidersModel, &ProvidersModel::providersChanged, this, &DocumentationView::emptyHistory);
 
     if (mProvidersModel->rowCount() > 0) {
         changedProvider(0);
     }
 }
 
 void DocumentationView::browseBack()
 {
     --mCurrent;
     mBack->setEnabled(mCurrent != mHistory.begin());
     mForward->setEnabled(true);
 
     updateView();
 }
 
 void DocumentationView::browseForward()
 {
     ++mCurrent;
     mForward->setEnabled(mCurrent+1 != mHistory.end());
     mBack->setEnabled(true);
 
     updateView();
 }
 
 void DocumentationView::showHome()
 {
     auto prov = mProvidersModel->provider(mProviders->currentIndex());
 
     showDocumentation(prov->homePage());
 }
 
 void DocumentationView::returnPressed()
 {
     // Exit if search text is empty. It's necessary because of empty
     // line edit text not leads to "empty" completer indexes.
     if (mIdentifiers->text().isEmpty())
         return;
 
     // Exit if completer popup has selected item - in this case 'Return'
     // key press emits QCompleter::activated signal which is already connected.
     if (mIdentifiers->completer()->popup()->currentIndex().isValid())
         return;
 
     // If user doesn't select any item in popup we will try to use the first row.
     if (mIdentifiers->completer()->setCurrentRow(0))
         changedSelection(mIdentifiers->completer()->currentIndex());
 }
 
 void DocumentationView::changedSelection(const QModelIndex& idx)
 {
     if (idx.isValid()) {
+        // Skip view update if user try to show already opened documentation
+        mIdentifiers->setText(idx.data(Qt::DisplayRole).toString());
+        if (mIdentifiers->text() == (*mCurrent)->name()) {
+            return;
+        }
+
         IDocumentationProvider* prov = mProvidersModel->provider(mProviders->currentIndex());
         auto doc = prov->documentationForIndex(idx);
         if (doc) {
             showDocumentation(doc);
         }
     }
 }
 
 void DocumentationView::showDocumentation(const IDocumentation::Ptr& doc)
 {
     qCDebug(DOCUMENTATION) << "showing" << doc->name();
 
     addHistory(doc);
     updateView();
 }
 
 void DocumentationView::addHistory(const IDocumentation::Ptr& doc)
 {
     mBack->setEnabled(!mHistory.isEmpty());
     mForward->setEnabled(false);
 
     // clear all history following the current item, unless we're already
     // at the end (otherwise this code crashes when history is empty, which
     // happens when addHistory is first called on startup to add the
     // homepage)
     if (mCurrent+1 < mHistory.end()) {
         mHistory.erase(mCurrent+1, mHistory.end());
     }
 
     mHistory.append(doc);
     mCurrent = mHistory.end()-1;
 
     // NOTE: we assume an existing widget was used to navigate somewhere
     //       but this history entry actually contains the new info for the
     //       title... this is ugly and should be refactored somehow
     if (mIdentifiers->completer()->model() == (*mCurrent)->provider()->indexModel()) {
         mIdentifiers->setText((*mCurrent)->name());
     }
 }
 
 void DocumentationView::emptyHistory()
 {
     mHistory.clear();
     mCurrent = mHistory.end();
     mBack->setEnabled(false);
     mForward->setEnabled(false);
     if (mProviders->count() > 0) {
         mProviders->setCurrentIndex(0);
         changedProvider(0);
     }
 }
 
 void DocumentationView::updateView()
 {
     mProviders->setCurrentIndex(mProvidersModel->rowForProvider((*mCurrent)->provider()));
     mIdentifiers->completer()->setModel((*mCurrent)->provider()->indexModel());
     mIdentifiers->setText((*mCurrent)->name());
+    mIdentifiers->completer()->setCompletionPrefix((*mCurrent)->name());
 
     QLayoutItem* lastview = layout()->takeAt(1);
     Q_ASSERT(lastview);
 
     if (lastview->widget()->parent() == this) {
         lastview->widget()->deleteLater();
     }
 
     delete lastview;
 
     mFindDoc->setEnabled(false);
     QWidget* w = (*mCurrent)->documentationWidget(mFindDoc, this);
     Q_ASSERT(w);
     QWidget::setTabOrder(mIdentifiers, w);
 
     mFind->setEnabled(mFindDoc->isEnabled());
     if (!mFindDoc->isEnabled()) {
         mFindDoc->hide();
     }
 
     QLayoutItem* findWidget = layout()->takeAt(1);
     layout()->addWidget(w);
     layout()->addItem(findWidget);
 }
 
 void DocumentationView::changedProvider(int row)
 {
     mIdentifiers->completer()->setModel(mProvidersModel->provider(row)->indexModel());
     mIdentifiers->clear();
 
     showHome();
 }
 
 ////////////// ProvidersModel //////////////////
 
 ProvidersModel::ProvidersModel(QObject* parent)
     : QAbstractListModel(parent)
     , mProviders(ICore::self()->documentationController()->documentationProviders())
 {
     connect(ICore::self()->pluginController(), &IPluginController::unloadingPlugin, this, &ProvidersModel::unloaded);
     connect(ICore::self()->pluginController(), &IPluginController::pluginLoaded, this, &ProvidersModel::loaded);
     connect(ICore::self()->documentationController(), &IDocumentationController::providersChanged, this, &ProvidersModel::reloadProviders);
 }
 
 void ProvidersModel::reloadProviders()
 {
     beginResetModel();
     mProviders = ICore::self()->documentationController()->documentationProviders();
 
     std::sort(mProviders.begin(), mProviders.end(),
               [](const KDevelop::IDocumentationProvider* a, const KDevelop::IDocumentationProvider* b) {
         return a->name() < b->name();
     });
 
     endResetModel();
     emit providersChanged();
 }
 
 QVariant ProvidersModel::data(const QModelIndex& index, int role) const
 {
     if (index.row() >= mProviders.count() || index.row() < 0)
         return QVariant();
 
     QVariant ret;
     switch (role)
     {
     case Qt::DisplayRole:
         ret = provider(index.row())->name();
         break;
     case Qt::DecorationRole:
         ret = provider(index.row())->icon();
         break;
     }
     return ret;
 }
 
 void ProvidersModel::addProvider(IDocumentationProvider* provider)
 {
     if (!provider || mProviders.contains(provider))
         return;
 
     int pos = 0;
     while (pos < mProviders.size() && mProviders[pos]->name() < provider->name())
         ++pos;
 
     beginInsertRows(QModelIndex(), pos, pos);
     mProviders.insert(pos, provider);
     endInsertRows();
 
     emit providersChanged();
 }
 
 void ProvidersModel::removeProvider(IDocumentationProvider* provider)
 {
     int pos;
     if (!provider || (pos = mProviders.indexOf(provider)) < 0)
         return;
 
     beginRemoveRows(QModelIndex(), pos, pos);
     mProviders.removeAt(pos);
     endRemoveRows();
 
     emit providersChanged();
 }
 
 void ProvidersModel::unloaded(IPlugin* plugin)
 {
     removeProvider(plugin->extension<IDocumentationProvider>());
 
     IDocumentationProviderProvider* providerProvider = plugin->extension<IDocumentationProviderProvider>();
     if (providerProvider) {
         foreach(IDocumentationProvider* provider, providerProvider->providers())
             removeProvider(provider);
     }
 }
 
 void ProvidersModel::loaded(IPlugin* plugin)
 {
     addProvider(plugin->extension<IDocumentationProvider>());
 
     IDocumentationProviderProvider* providerProvider = plugin->extension<IDocumentationProviderProvider>();
     if (providerProvider) {
         foreach(IDocumentationProvider* provider, providerProvider->providers())
             addProvider(provider);
     }
 }
 
 int ProvidersModel::rowCount(const QModelIndex& parent) const
 {
     return parent.isValid() ? 0 : mProviders.count();
 }
 
 int ProvidersModel::rowForProvider(IDocumentationProvider* provider)
 {
     return mProviders.indexOf(provider);
 }
 
 IDocumentationProvider* ProvidersModel::provider(int pos) const
 {
     return mProviders[pos];
 }
 
 QList<IDocumentationProvider*> ProvidersModel::providers()
 {
     return mProviders;
 }
diff --git a/language/backgroundparser/backgroundparser.cpp b/language/backgroundparser/backgroundparser.cpp
index 3491149e32..80074d1c0f 100644
--- a/language/backgroundparser/backgroundparser.cpp
+++ b/language/backgroundparser/backgroundparser.cpp
@@ -1,901 +1,913 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2006 Adam Treat <treat@kde.org>
  * Copyright 2007 Kris Wong <kris.p.wong@gmail.com>
  * Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * 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 "backgroundparser.h"
 
 #include <QList>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QTimer>
 #include <QThread>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 
 #include <ktexteditor/document.h>
 
 #include <ThreadWeaver/State>
 #include <ThreadWeaver/ThreadWeaver>
 #include <ThreadWeaver/DebuggingAids>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/ilanguagesupport.h>
 #include <interfaces/isession.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 
 #include "util/debug.h"
 
 #include "parsejob.h"
 #include <editor/modificationrevisionset.h>
 
 using namespace KDevelop;
 
 namespace {
 
 const bool separateThreadForHighPriority = true;
 
 /**
  * Elides string in @p path, e.g. "VEEERY/LONG/PATH" -> ".../LONG/PATH"
  * - probably much faster than QFontMetrics::elidedText()
  * - we dont need a widget context
  * - takes path separators into account
  *
  * @p width Maximum number of characters
  *
  * TODO: Move to kdevutil?
  */
 QString elidedPathLeft(const QString& path, int width)
 {
     static const QChar separator = QDir::separator();
     static const QString placeholder = QStringLiteral("...");
 
     if (path.size() <= width) {
         return path;
     }
 
     int start = (path.size() - width) + placeholder.size();
     int pos = path.indexOf(separator, start);
     if (pos == -1) {
         pos = start; // no separator => just cut off the path at the beginning
     }
     Q_ASSERT(path.size() - pos >= 0 && path.size() - pos <= width);
 
     QStringRef elidedText = path.rightRef(path.size() - pos);
     QString result = placeholder;
     result.append(elidedText);
     return result;
 }
 
 /**
  * @return true if @p url is non-empty, valid and has a clean path, false otherwise.
  */
 inline bool isValidURL(const IndexedString& url)
 {
     if (url.isEmpty()) {
         return false;
     }
     QUrl original = url.toUrl();
     if (!original.isValid() || original.isRelative() || original.fileName().isEmpty()) {
         qCWarning(LANGUAGE) << "INVALID URL ENCOUNTERED:" << url << original;
         return false;
     }
     QUrl cleaned = original.adjusted(QUrl::NormalizePathSegments);
     return original == cleaned;
 }
 
 }
 
 struct DocumentParseTarget
 {
     QPointer<QObject> notifyWhenReady;
     int priority;
     TopDUContext::Features features;
     ParseJob::SequentialProcessingFlags sequentialProcessingFlags;
 
     bool operator==(const DocumentParseTarget& rhs) const
     {
         return notifyWhenReady == rhs.notifyWhenReady
             && priority == rhs.priority
             && features == rhs.features;
     }
 };
 
 inline uint qHash(const DocumentParseTarget& target)
 {
     return target.features * 7 + target.priority * 13 + target.sequentialProcessingFlags * 17
                                + reinterpret_cast<size_t>(target.notifyWhenReady.data());
 };
 
 struct DocumentParsePlan
 {
     QSet<DocumentParseTarget> targets;
 
     ParseJob::SequentialProcessingFlags sequentialProcessingFlags() const
     {
         //Pick the strictest possible flags
         ParseJob::SequentialProcessingFlags ret = ParseJob::IgnoresSequentialProcessing;
         foreach(const DocumentParseTarget &target, targets) {
             ret |= target.sequentialProcessingFlags;
         }
         return ret;
     }
 
     int priority() const
     {
         //Pick the best priority
         int ret = BackgroundParser::WorstPriority;
         foreach(const DocumentParseTarget &target, targets) {
             if(target.priority < ret) {
                 ret = target.priority;
             }
         }
         return ret;
     }
 
     TopDUContext::Features features() const
     {
         //Pick the best features
         TopDUContext::Features ret = (TopDUContext::Features)0;
         foreach(const DocumentParseTarget &target, targets) {
             ret = (TopDUContext::Features) (ret | target.features);
         }
         return ret;
     }
 
     QList<QPointer<QObject> > notifyWhenReady() const
     {
         QList<QPointer<QObject> > ret;
 
         foreach(const DocumentParseTarget &target, targets) {
             if(target.notifyWhenReady)
                 ret << target.notifyWhenReady;
         }
 
         return ret;
     }
 };
 
 Q_DECLARE_TYPEINFO(DocumentParseTarget, Q_MOVABLE_TYPE);
 Q_DECLARE_TYPEINFO(DocumentParsePlan, Q_MOVABLE_TYPE);
 
 class KDevelop::BackgroundParserPrivate
 {
 public:
     BackgroundParserPrivate(BackgroundParser *parser, ILanguageController *languageController)
         :m_parser(parser), m_languageController(languageController), m_shuttingDown(false), m_mutex(QMutex::Recursive)
     {
         parser->d = this; //Set this so we can safely call back BackgroundParser from within loadSettings()
 
         m_timer.setSingleShot(true);
-        m_delay = 500;
-        m_threads = 1;
-        m_doneParseJobs = 0;
-        m_maxParseJobs = 0;
-        m_neededPriority = BackgroundParser::WorstPriority;
+        m_progressTimer.setSingleShot(true);
+        m_progressTimer.setInterval(500);
 
         ThreadWeaver::setDebugLevel(true, 1);
 
         QObject::connect(&m_timer, &QTimer::timeout, m_parser, &BackgroundParser::parseDocuments);
+        QObject::connect(&m_progressTimer, &QTimer::timeout, m_parser, &BackgroundParser::updateProgressBar);
     }
 
     void startTimerThreadSafe(int delay) {
         QMetaObject::invokeMethod(m_parser, "startTimer", Qt::QueuedConnection, Q_ARG(int, delay));
     }
 
     ~BackgroundParserPrivate()
     {
         m_weaver.resume();
         m_weaver.finish();
     }
 
     // Non-mutex guarded functions, only call with m_mutex acquired.
 
     int currentBestRunningPriority() const
     {
         int bestRunningPriority = BackgroundParser::WorstPriority;
         for (const auto* decorator : m_parseJobs) {
             const ParseJob* parseJob = dynamic_cast<const ParseJob*>(decorator->job());
             Q_ASSERT(parseJob);
             if (parseJob->respectsSequentialProcessing() && parseJob->parsePriority() < bestRunningPriority) {
                 bestRunningPriority = parseJob->parsePriority();
             }
         }
         return bestRunningPriority;
     }
 
     IndexedString nextDocumentToParse() const
     {
         // Before starting a new job, first wait for all higher-priority ones to finish.
         // That way, parse job priorities can be used for dependency handling.
         const int bestRunningPriority = currentBestRunningPriority();
 
         for (auto it1 = m_documentsForPriority.begin();
              it1 != m_documentsForPriority.end(); ++it1 )
         {
             const auto priority = it1.key();
             if(priority > m_neededPriority)
                 break; //The priority is not good enough to be processed right now
 
             if (m_parseJobs.count() >= m_threads && priority > BackgroundParser::NormalPriority && !specialParseJob) {
                 break; //The additional parsing thread is reserved for higher priority parsing
             }
 
             for (const auto& url : it1.value()) {
                 // When a document is scheduled for parsing while it is being parsed, it will be parsed
                 // again once the job finished, but not now.
                 if (m_parseJobs.contains(url)) {
                     continue;
                 }
 
                 Q_ASSERT(m_documents.contains(url));
                 const auto& parsePlan = m_documents[url];
                 // If the current job requires sequential processing, but not all jobs with a better priority have been
                 // completed yet, it will not be created now.
                 if (    parsePlan.sequentialProcessingFlags() & ParseJob::RequiresSequentialProcessing
                      && parsePlan.priority() > bestRunningPriority )
                 {
                     continue;
                 }
 
                 return url;
             }
         }
         return {};
     }
 
     /**
      * Create a single delayed parse job
      *
      * E.g. jobs for documents which have been changed by the user, but also to
      * handle initial startup where we parse all project files.
      */
     void parseDocumentsInternal()
     {
         if(m_shuttingDown)
             return;
 
         //Only create parse-jobs for up to thread-count * 2 documents, so we don't fill the memory unnecessarily
         if (m_parseJobs.count() >= m_threads+1
             || (m_parseJobs.count() >= m_threads && !separateThreadForHighPriority))
         {
             return;
         }
 
         const auto& url = nextDocumentToParse();
         if (!url.isEmpty()) {
             qCDebug(LANGUAGE) << "creating parse-job" << url << "new count of active parse-jobs:" << m_parseJobs.count() + 1;
 
             const QString elidedPathString = elidedPathLeft(url.str(), 70);
             emit m_parser->showMessage(m_parser, i18n("Parsing: %1", elidedPathString));
 
             ThreadWeaver::QObjectDecorator* decorator = nullptr;
             {
                 // copy shared data before unlocking the mutex
                 const auto parsePlanConstIt = m_documents.constFind(url);
                 const DocumentParsePlan parsePlan = *parsePlanConstIt;
 
                 // we must not lock the mutex while creating a parse job
                 // this could in turn lock e.g. the DUChain and then
                 // we have a classic lock order inversion (since, usually,
                 // we lock first the duchain and then our background parser
                 // mutex)
                 // see also: https://bugs.kde.org/show_bug.cgi?id=355100
                 m_mutex.unlock();
                 decorator = createParseJob(url, parsePlan);
                 m_mutex.lock();
             }
 
             // iterator might get invalid during the time we didn't have the lock
             // search again
             const auto parsePlanIt = m_documents.find(url);
             if (parsePlanIt != m_documents.end()) {
                 // Remove all mentions of this document.
                 for (const auto& target : parsePlanIt->targets) {
                     m_documentsForPriority[target.priority].remove(url);
                 }
                 m_documents.erase(parsePlanIt);
             } else {
                 qWarning(LANGUAGE) << "Document got removed during parse job creation:" << url;
             }
 
             if (decorator) {
                 if(m_parseJobs.count() == m_threads+1 && !specialParseJob)
                     specialParseJob = decorator; //This parse-job is allocated into the reserved thread
 
                 m_parseJobs.insert(url, decorator);
                 m_weaver.enqueue(ThreadWeaver::JobPointer(decorator));
             } else {
                 --m_maxParseJobs;
             }
 
             if (!m_documents.isEmpty()) {
                 // Only try creating one parse-job at a time, else we might iterate through thousands of files
                 // without finding a language-support, and block the UI for a long time.
                 QMetaObject::invokeMethod(m_parser, "parseDocuments", Qt::QueuedConnection);
             } else {
                 // make sure we cleaned up properly
                 // TODO: also empty m_documentsForPriority when m_documents is empty? or do we want to keep capacity?
                 Q_ASSERT(std::none_of(m_documentsForPriority.constBegin(), m_documentsForPriority.constEnd(),
                                         [] (const QSet<IndexedString>& docs) {
                                         return !docs.isEmpty();
                                         }));
             }
         }
 
-        m_parser->updateProgressBar();
+        m_parser->updateProgressData();
 
         //We don't hide the progress-bar in updateProgressBar, so it doesn't permanently flash when a document is reparsed again and again.
         if(m_doneParseJobs == m_maxParseJobs
             || (m_neededPriority == BackgroundParser::BestPriority && m_weaver.queueLength() == 0))
         {
             emit m_parser->hideProgress(m_parser);
         }
     }
 
     // NOTE: you must not access any of the data structures that are protected by any of the
     //       background parser internal mutexes in this method
     //       see also: https://bugs.kde.org/show_bug.cgi?id=355100
     ThreadWeaver::QObjectDecorator* createParseJob(const IndexedString& url, const DocumentParsePlan& parsePlan)
     {
         ///FIXME: use IndexedString in the other APIs as well! Esp. for createParseJob!
         QUrl qUrl = url.toUrl();
         const auto languages = m_languageController->languagesForUrl(qUrl);
         const auto& notifyWhenReady = parsePlan.notifyWhenReady();
         for (const auto language : languages) {
             if (!language) {
                 qCWarning(LANGUAGE) << "got zero language for" << qUrl;
                 continue;
             }
 
             ParseJob* job = language->createParseJob(url);
             if (!job) {
                 continue; // Language part did not produce a valid ParseJob.
             }
 
             job->setParsePriority(parsePlan.priority());
             job->setMinimumFeatures(parsePlan.features());
             job->setNotifyWhenReady(notifyWhenReady);
             job->setSequentialProcessingFlags(parsePlan.sequentialProcessingFlags());
 
             ThreadWeaver::QObjectDecorator* decorator = new ThreadWeaver::QObjectDecorator(job);
 
             QObject::connect(decorator, &ThreadWeaver::QObjectDecorator::done,
                              m_parser, &BackgroundParser::parseComplete);
             QObject::connect(decorator, &ThreadWeaver::QObjectDecorator::failed,
                              m_parser, &BackgroundParser::parseComplete);
             QObject::connect(job, &ParseJob::progress,
                              m_parser, &BackgroundParser::parseProgress, Qt::QueuedConnection);
 
             // TODO more thinking required here to support multiple parse jobs per url (where multiple language plugins want to parse)
             return decorator;
         }
 
         if (languages.isEmpty())
             qCDebug(LANGUAGE) << "found no languages for url" << qUrl;
         else
             qCDebug(LANGUAGE) << "could not create parse-job for url" << qUrl;
 
         //Notify that we failed
         for (const auto& n : notifyWhenReady) {
             if (!n) {
                 continue;
             }
 
             QMetaObject::invokeMethod(n.data(), "updateReady", Qt::QueuedConnection,
                                       Q_ARG(KDevelop::IndexedString, url),
                                       Q_ARG(KDevelop::ReferencedTopDUContext, ReferencedTopDUContext()));
         }
 
         return nullptr;
     }
 
 
     void loadSettings()
     {
         ///@todo re-load settings when they have been changed!
         Q_ASSERT(ICore::self()->activeSession());
         KConfigGroup config(ICore::self()->activeSession()->config(), "Background Parser");
 
         // stay backwards compatible
         KConfigGroup oldConfig(KSharedConfig::openConfig(), "Background Parser");
 #define BACKWARDS_COMPATIBLE_ENTRY(entry, default) \
 config.readEntry(entry, oldConfig.readEntry(entry, default))
 
         m_delay = BACKWARDS_COMPATIBLE_ENTRY("Delay", 500);
         m_timer.setInterval(m_delay);
         m_threads = 0;
 
         if (qEnvironmentVariableIsSet("KDEV_BACKGROUNDPARSER_MAXTHREADS")) {
             m_parser->setThreadCount(qgetenv("KDEV_BACKGROUNDPARSER_MAXTHREADS").toInt());
         } else {
             m_parser->setThreadCount(BACKWARDS_COMPATIBLE_ENTRY("Number of Threads", QThread::idealThreadCount()));
         }
 
         resume();
 
         if (BACKWARDS_COMPATIBLE_ENTRY("Enabled", true)) {
             m_parser->enableProcessing();
         } else {
             m_parser->disableProcessing();
         }
     }
 
     void suspend()
     {
         qCDebug(LANGUAGE) << "Suspending background parser";
 
         bool s = m_weaver.state()->stateId() == ThreadWeaver::Suspended ||
                  m_weaver.state()->stateId() == ThreadWeaver::Suspending;
 
         if (s) { // Already suspending
             qCWarning(LANGUAGE) << "Already suspended or suspending";
             return;
         }
 
         m_timer.stop();
         m_weaver.suspend();
     }
 
     void resume()
     {
         bool s = m_weaver.state()->stateId() == ThreadWeaver::Suspended ||
                  m_weaver.state()->stateId() == ThreadWeaver::Suspending;
 
         if (m_timer.isActive() && !s) { // Not suspending
             return;
         }
 
         m_timer.start(m_delay);
         m_weaver.resume();
     }
 
     BackgroundParser *m_parser;
     ILanguageController* m_languageController;
 
     //Current parse-job that is executed in the additional thread
     QPointer<QObject> specialParseJob;
 
     QTimer m_timer;
-    int m_delay;
-    int m_threads;
+    int m_delay = 500;
+    int m_threads = 1;
 
     bool m_shuttingDown;
 
     // A list of documents that are planned to be parsed, and their priority
     QHash<IndexedString, DocumentParsePlan > m_documents;
     // The documents ordered by priority
     QMap<int, QSet<IndexedString> > m_documentsForPriority;
     // Currently running parse jobs
     QHash<IndexedString, ThreadWeaver::QObjectDecorator*> m_parseJobs;
     // The url for each managed document. Those may temporarily differ from the real url.
     QHash<KTextEditor::Document*, IndexedString> m_managedTextDocumentUrls;
     // Projects currently in progress of loading
     QSet<IProject*> m_loadingProjects;
 
     ThreadWeaver::Queue m_weaver;
 
     // generic high-level mutex
     QMutex m_mutex;
 
     // local mutex only protecting m_managed
     QMutex m_managedMutex;
     // A change tracker for each managed document
     QHash<IndexedString, DocumentChangeTracker*> m_managed;
 
-    int m_maxParseJobs;
-    int m_doneParseJobs;
+    int m_maxParseJobs = 0;
+    int m_doneParseJobs = 0;
     QHash<KDevelop::ParseJob*, float> m_jobProgress;
-    int m_neededPriority; //The minimum priority needed for processed jobs
+    /// The minimum priority needed for processed jobs
+    int m_neededPriority = BackgroundParser::WorstPriority;
+    int m_progressMax = 0;
+    int m_progressDone = 0;
+    QTimer m_progressTimer;
 };
 
 BackgroundParser::BackgroundParser(ILanguageController *languageController)
     : QObject(languageController), d(new BackgroundParserPrivate(this, languageController))
 {
     Q_ASSERT(ICore::self()->documentController());
     connect(ICore::self()->documentController(), &IDocumentController::documentLoaded, this, &BackgroundParser::documentLoaded);
     connect(ICore::self()->documentController(), &IDocumentController::documentUrlChanged, this, &BackgroundParser::documentUrlChanged);
     connect(ICore::self()->documentController(), &IDocumentController::documentClosed, this, &BackgroundParser::documentClosed);
     connect(ICore::self(), &ICore::aboutToShutdown, this, &BackgroundParser::aboutToQuit);
 
     bool connected = QObject::connect(ICore::self()->projectController(),
                                       &IProjectController::projectAboutToBeOpened,
                                       this, &BackgroundParser::projectAboutToBeOpened);
     Q_ASSERT(connected);
     connected = QObject::connect(ICore::self()->projectController(),
                                  &IProjectController::projectOpened,
                                  this, &BackgroundParser::projectOpened);
     Q_ASSERT(connected);
     connected = QObject::connect(ICore::self()->projectController(),
                                  &IProjectController::projectOpeningAborted,
                                  this, &BackgroundParser::projectOpeningAborted);
     Q_ASSERT(connected);
     Q_UNUSED(connected);
 }
 
 void BackgroundParser::aboutToQuit()
 {
     d->m_shuttingDown = true;
 }
 
 BackgroundParser::~BackgroundParser()
 {
     delete d;
 }
 
 QString BackgroundParser::statusName() const
 {
     return i18n("Background Parser");
 }
 
 void BackgroundParser::loadSettings()
 {
     d->loadSettings();
 }
 
 void BackgroundParser::parseProgress(KDevelop::ParseJob* job, float value, QString text)
 {
     Q_UNUSED(text)
     d->m_jobProgress[job] = value;
-    updateProgressBar();
+    updateProgressData();
 }
 
 void BackgroundParser::revertAllRequests(QObject* notifyWhenReady)
 {
     QMutexLocker lock(&d->m_mutex);
     for (auto it = d->m_documents.begin(); it != d->m_documents.end(); ) {
 
         d->m_documentsForPriority[it.value().priority()].remove(it.key());
 
         foreach ( const DocumentParseTarget& target, (*it).targets ) {
             if ( notifyWhenReady && target.notifyWhenReady.data() == notifyWhenReady ) {
                 (*it).targets.remove(target);
             }
         }
 
         if((*it).targets.isEmpty()) {
             it = d->m_documents.erase(it);
             --d->m_maxParseJobs;
 
             continue;
         }
 
         d->m_documentsForPriority[it.value().priority()].insert(it.key());
         ++it;
     }
 }
 
 void BackgroundParser::addDocument(const IndexedString& url, TopDUContext::Features features, int priority,
                                    QObject* notifyWhenReady, ParseJob::SequentialProcessingFlags flags, int delay)
 {
 //     qCDebug(LANGUAGE) << "BackgroundParser::addDocument" << url.toUrl();
     Q_ASSERT(isValidURL(url));
     QMutexLocker lock(&d->m_mutex);
     {
         DocumentParseTarget target;
         target.priority = priority;
         target.features = features;
         target.sequentialProcessingFlags = flags;
         target.notifyWhenReady = QPointer<QObject>(notifyWhenReady);
 
         auto it = d->m_documents.find(url);
 
         if (it != d->m_documents.end()) {
             //Update the stored plan
 
             d->m_documentsForPriority[it.value().priority()].remove(url);
             it.value().targets << target;
             d->m_documentsForPriority[it.value().priority()].insert(url);
         }else{
 //             qCDebug(LANGUAGE) << "BackgroundParser::addDocument: queuing" << cleanedUrl;
             d->m_documents[url].targets << target;
             d->m_documentsForPriority[d->m_documents[url].priority()].insert(url);
             ++d->m_maxParseJobs; //So the progress-bar waits for this document
         }
 
         if ( delay == ILanguageSupport::DefaultDelay ) {
             delay = d->m_delay;
         }
         d->startTimerThreadSafe(delay);
     }
 }
 
 void BackgroundParser::removeDocument(const IndexedString& url, QObject* notifyWhenReady)
 {
     Q_ASSERT(isValidURL(url));
 
     QMutexLocker lock(&d->m_mutex);
 
     if(d->m_documents.contains(url)) {
 
         d->m_documentsForPriority[d->m_documents[url].priority()].remove(url);
 
         foreach(const DocumentParseTarget& target, d->m_documents[url].targets) {
             if(target.notifyWhenReady.data() == notifyWhenReady) {
                 d->m_documents[url].targets.remove(target);
             }
         }
 
         if(d->m_documents[url].targets.isEmpty()) {
             d->m_documents.remove(url);
             --d->m_maxParseJobs;
         }else{
             //Insert with an eventually different priority
             d->m_documentsForPriority[d->m_documents[url].priority()].insert(url);
         }
     }
 }
 
 void BackgroundParser::parseDocuments()
 {
     if (!d->m_loadingProjects.empty()) {
         startTimer(d->m_delay);
         return;
     }
     QMutexLocker lock(&d->m_mutex);
 
     d->parseDocumentsInternal();
 }
 
 void BackgroundParser::parseComplete(const ThreadWeaver::JobPointer& job)
 {
     auto decorator = dynamic_cast<ThreadWeaver::QObjectDecorator*>(job.data());
     Q_ASSERT(decorator);
     ParseJob* parseJob = dynamic_cast<ParseJob*>(decorator->job());
     Q_ASSERT(parseJob);
     emit parseJobFinished(parseJob);
 
     {
         QMutexLocker lock(&d->m_mutex);
 
         d->m_parseJobs.remove(parseJob->document());
 
         d->m_jobProgress.remove(parseJob);
 
         ++d->m_doneParseJobs;
-        updateProgressBar();
+        updateProgressData();
     }
 
     //Continue creating more parse-jobs
     QMetaObject::invokeMethod(this, "parseDocuments", Qt::QueuedConnection);
 }
 
 void BackgroundParser::disableProcessing()
 {
     setNeededPriority(BestPriority);
 }
 
 void BackgroundParser::enableProcessing()
 {
     setNeededPriority(WorstPriority);
 }
 
 int BackgroundParser::priorityForDocument(const IndexedString& url) const
 {
     Q_ASSERT(isValidURL(url));
     QMutexLocker lock(&d->m_mutex);
     return d->m_documents[url].priority();
 }
 
 bool BackgroundParser::isQueued(const IndexedString& url) const
 {
     Q_ASSERT(isValidURL(url));
     QMutexLocker lock(&d->m_mutex);
     return d->m_documents.contains(url);
 }
 
 int BackgroundParser::queuedCount() const
 {
     QMutexLocker lock(&d->m_mutex);
     return d->m_documents.count();
 }
 
 bool BackgroundParser::isIdle() const
 {
     QMutexLocker lock(&d->m_mutex);
     return d->m_documents.isEmpty() && d->m_weaver.isIdle();
 }
 
 void BackgroundParser::setNeededPriority(int priority)
 {
     QMutexLocker lock(&d->m_mutex);
     d->m_neededPriority = priority;
     d->startTimerThreadSafe(d->m_delay);
 }
 
 void BackgroundParser::abortAllJobs()
 {
     qCDebug(LANGUAGE) << "Aborting all parse jobs";
 
     d->m_weaver.requestAbort();
 }
 
 void BackgroundParser::suspend()
 {
     d->suspend();
 
     emit hideProgress(this);
 }
 
 void BackgroundParser::resume()
 {
     d->resume();
-    updateProgressBar();
+    updateProgressData();
 }
 
-void BackgroundParser::updateProgressBar()
+void BackgroundParser::updateProgressData()
 {
     if (d->m_doneParseJobs >= d->m_maxParseJobs) {
         if(d->m_doneParseJobs > d->m_maxParseJobs) {
             qCDebug(LANGUAGE) << "m_doneParseJobs larger than m_maxParseJobs:" << d->m_doneParseJobs << d->m_maxParseJobs;
         }
         d->m_doneParseJobs = 0;
         d->m_maxParseJobs = 0;
     } else {
         float additionalProgress = 0;
         for (auto it = d->m_jobProgress.constBegin(); it != d->m_jobProgress.constEnd(); ++it) {
             additionalProgress += *it;
         }
 
-        emit showProgress(this, 0, d->m_maxParseJobs*1000, (additionalProgress + d->m_doneParseJobs)*1000);
+        d->m_progressMax = d->m_maxParseJobs*1000;
+        d->m_progressDone = (additionalProgress + d->m_doneParseJobs)*1000;
+
+        if (!d->m_progressTimer.isActive()) {
+            d->m_progressTimer.start();
+        }
     }
 }
 
 ParseJob* BackgroundParser::parseJobForDocument(const IndexedString& document) const
 {
     Q_ASSERT(isValidURL(document));
 
     QMutexLocker lock(&d->m_mutex);
     auto decorator = d->m_parseJobs.value(document);
     return decorator ? dynamic_cast<ParseJob*>(decorator->job()) : nullptr;
 }
 
 void BackgroundParser::setThreadCount(int threadCount)
 {
     if (d->m_threads != threadCount) {
         d->m_threads = threadCount;
         d->m_weaver.setMaximumNumberOfThreads(d->m_threads+1); //1 Additional thread for high-priority parsing
     }
 }
 
 int BackgroundParser::threadCount() const
 {
     return d->m_threads;
 }
 
 void BackgroundParser::setDelay(int milliseconds)
 {
     if (d->m_delay != milliseconds) {
         d->m_delay = milliseconds;
         d->m_timer.setInterval(d->m_delay);
     }
 }
 
 QList< IndexedString > BackgroundParser::managedDocuments()
 {
     QMutexLocker l(&d->m_managedMutex);
     return d->m_managed.keys();
 }
 
 DocumentChangeTracker* BackgroundParser::trackerForUrl(const KDevelop::IndexedString& url) const
 {
     if (url.isEmpty()) {
         // this happens e.g. when setting the final location of a problem that is not
         // yet associated with a top ctx.
         return nullptr;
     }
     if ( !isValidURL(url) ) {
         qWarning() << "Tracker requested for invalild URL:" << url.toUrl();
     }
     Q_ASSERT(isValidURL(url));
 
     QMutexLocker l(&d->m_managedMutex);
     return d->m_managed.value(url, nullptr);
 }
 
 void BackgroundParser::documentClosed(IDocument* document)
 {
     QMutexLocker l(&d->m_mutex);
 
     if(document->textDocument())
     {
         KTextEditor::Document* textDocument = document->textDocument();
 
         if(!d->m_managedTextDocumentUrls.contains(textDocument))
             return; // Probably the document had an invalid url, and thus it wasn't added to the background parser
 
         Q_ASSERT(d->m_managedTextDocumentUrls.contains(textDocument));
 
         IndexedString url(d->m_managedTextDocumentUrls[textDocument]);
         
         QMutexLocker l2(&d->m_managedMutex);
         Q_ASSERT(d->m_managed.contains(url));
 
         qCDebug(LANGUAGE) << "removing" << url.str() << "from background parser";
         delete d->m_managed[url];
         d->m_managedTextDocumentUrls.remove(textDocument);
         d->m_managed.remove(url);
     }
 }
 
 void BackgroundParser::documentLoaded( IDocument* document )
 {
     QMutexLocker l(&d->m_mutex);
     if(document->textDocument() && document->textDocument()->url().isValid())
     {
         KTextEditor::Document* textDocument = document->textDocument();
 
         IndexedString url(document->url());
         // Some debugging because we had issues with this
 
         QMutexLocker l2(&d->m_managedMutex);
         if(d->m_managed.contains(url) && d->m_managed[url]->document() == textDocument)
         {
             qCDebug(LANGUAGE) << "Got redundant documentLoaded from" << document->url() << textDocument;
             return;
         }
 
         qCDebug(LANGUAGE) << "Creating change tracker for " << document->url();
 
 
         Q_ASSERT(!d->m_managed.contains(url));
         Q_ASSERT(!d->m_managedTextDocumentUrls.contains(textDocument));
 
         d->m_managedTextDocumentUrls[textDocument] = url;
         d->m_managed.insert(url, new DocumentChangeTracker(textDocument));
     }else{
         qCDebug(LANGUAGE) << "NOT creating change tracker for" << document->url();
     }
 }
 
 void BackgroundParser::documentUrlChanged(IDocument* document)
 {
     documentClosed(document);
 
     // Only call documentLoaded if the file wasn't renamed to a filename that is already tracked.
     if(document->textDocument() && !trackerForUrl(IndexedString(document->textDocument()->url())))
         documentLoaded(document);
 }
 
 void BackgroundParser::startTimer(int delay) {
     d->m_timer.start(delay);
 }
 
 void BackgroundParser::projectAboutToBeOpened(IProject* project)
 {
     d->m_loadingProjects.insert(project);
 }
 
 void BackgroundParser::projectOpened(IProject* project)
 {
     d->m_loadingProjects.remove(project);
 }
 
 void BackgroundParser::projectOpeningAborted(IProject* project)
 {
     d->m_loadingProjects.remove(project);
 }
+
+void BackgroundParser::updateProgressBar()
+{
+    emit showProgress(this, 0, d->m_progressMax, d->m_progressDone);
+}
diff --git a/language/backgroundparser/backgroundparser.h b/language/backgroundparser/backgroundparser.h
index d23a05897b..c14b75b4a5 100644
--- a/language/backgroundparser/backgroundparser.h
+++ b/language/backgroundparser/backgroundparser.h
@@ -1,245 +1,246 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2006 Adam Treat <treat@kde.org>
  * Copyright 2007 Kris Wong <kris.p.wong@gmail.com>
  * Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * 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_BACKGROUNDPARSER_H
 #define KDEVPLATFORM_BACKGROUNDPARSER_H
 
 #include <QtCore/QMap>
 #include <QtCore/QPair>
 #include <QtCore/QMutex>
 #include <QtCore/QHash>
 
 #include <language/languageexport.h>
 #include <interfaces/istatus.h>
 #include <language/duchain/topducontext.h>
 #include "parsejob.h"
 
 class QMutex;
 
 namespace ThreadWeaver
 {
 class Job;
 class QObjectDecorator;
 class Weaver;
 }
 
 namespace KDevelop
 {
 
 class DocumentChangeTracker;
 
 class IDocument;
 class IProject;
 class ILanguageController;
 class ParseJob;
 class ParserDependencyPolicy;
 
 /**
  * This class handles the creation of parse jobs for given file URLs.
  *
  * For performance reasons you must always use clean, canonical URLs. If you do not do that,
  * issues might arise (and the debug build will assert).
  */
 class KDEVPLATFORMLANGUAGE_EXPORT BackgroundParser : public QObject, public IStatus
 {
     Q_OBJECT
     Q_INTERFACES( KDevelop::IStatus )
 
 public:
     explicit BackgroundParser(ILanguageController *languageController);
     ~BackgroundParser() override;
 
     QString statusName() const override;
 
     enum {
         BestPriority = -10000,  ///Best possible job-priority. No jobs should actually have this.
         NormalPriority = 0,     ///Standard job-priority. This priority is used for parse-jobs caused by document-editing/opening.
                                 ///There is an additional parsing-thread reserved for jobs with this and better priority, to improve responsiveness.
         InitialParsePriority = 10000, ///Priority used when adding file on project loading
         WorstPriority = 100000  ///Worst possible job-priority.
     };
 
     /**
      * Queries the background parser as to whether there is currently
      * a parse job for @p document, and if so, returns it.
      *
      * This may not contain all of the parse jobs that are intended
      * unless you call in from your job's ThreadWeaver::Job::aboutToBeQueued()
      * function.
      */
     Q_SCRIPTABLE ParseJob* parseJobForDocument(const IndexedString& document) const;
 
     /**
      * Set how many ThreadWeaver threads the background parser should set up and use.
      */
     Q_SCRIPTABLE void setThreadCount(int threadCount);
 
     /**
      * Return how many ThreadWeaver threads the background parser should set up and use.
      */
     Q_SCRIPTABLE int threadCount() const;
 
     /**
      * Set the delay in milliseconds before the background parser starts parsing.
      */
     Q_SCRIPTABLE void setDelay(int milliseconds);
 
     /**
      * Returns all documents that were added through addManagedTopRange. This is typically the currently
      * open documents.
      */
     Q_SCRIPTABLE QList<IndexedString> managedDocuments();
 
     /**
      * Returns the tracker for the given url if the document is being tracked, else returns zero.
      * This function is thread-safe, but the returned object also isn't, so you must not use it
      * when you're in a background thread without the foreground lock acquired.
      * */
     DocumentChangeTracker* trackerForUrl(const IndexedString& url) const;
 
 Q_SIGNALS:
     /** 
 	 * Emitted whenever a document parse-job has finished. 
 	 * The job contains the du-chain(if one was created) etc.
 	 *
 	 * The job is deleted after this signal has been emitted.  Receivers should not hold
 	 * references to it.
      *
      * Note that if you want to be get updated for all DUChain updates, use
      * DUChain::updateReady instead, as a single ParseJob may update multiple
      * DUChain top contexts.
      *
      * @sa DUChain::updateReady
 	 */
     void parseJobFinished(KDevelop::ParseJob* job);
 
     // Implementations of IStatus signals
     void clearMessage( KDevelop::IStatus* ) override;
     void showMessage( KDevelop::IStatus*, const QString & message, int timeout = 0) override;
     void hideProgress( KDevelop::IStatus* ) override;
     void showProgress( KDevelop::IStatus*, int minimum, int maximum, int value) override;
     void showErrorMessage( const QString&, int ) override;
 
 public Q_SLOTS:
     /**
      * Aborts all parse jobs
      */
     void abortAllJobs();
 
     /**
      * Suspends execution of the background parser
      */
     void suspend();
 
     /**
      * Resumes execution of the background parser
      */
     void resume();
 
     ///Reverts all requests that were made for the given notification-target.
     ///priorities and requested features will be reverted as well.
     ///When @p notifyWhenReady is set to a nullptr, all requests will be reverted.
     void revertAllRequests(QObject* notifyWhenReady);
 
     /**
      * Queues up the @p url to be parsed.
      * @p features The minimum features that should be computed for this top-context
      * @p priority A value that manages the order of parsing. Documents with lowest priority are parsed first.
      * @param notifyWhenReady An optional pointer to a QObject that should contain a slot
      *                        "void updateReady(KDevelop::IndexedString url, KDevelop::ReferencedTopDUContext topContext)".
      *                        The notification is guaranteed to be called once for each call to addDocument. The given top-context
      *                        may be invalid if the update failed.
      * @param flags Flags indicating how the document should be treated in the queue
      * @param delay_ms The delay in milliseconds to add the job with, or one of the values of the
      *                 ILanguageSupport::ReparseDelaySpecialValues enum.
      */
     void addDocument(const IndexedString& url,
                      TopDUContext::Features features = TopDUContext::VisibleDeclarationsAndContexts,
                      int priority = 0,
                      QObject* notifyWhenReady = nullptr,
                      ParseJob::SequentialProcessingFlags flags = ParseJob::IgnoresSequentialProcessing,
                      int delay_ms = ILanguageSupport::DefaultDelay);
 
     /**
      * Removes the @p url that is registered for the given notification from the url.
      *
      * @param notifyWhenReady Notifier the document was added with.
      */
     void removeDocument(const IndexedString& url, QObject* notifyWhenReady = nullptr);
 
     /**
      * Forces the current queue to be parsed.
      */
     void parseDocuments();
 
-    void updateProgressBar();
+    void updateProgressData();
 
     ///Disables processing for all jobs that have a worse priority than @param priority
     ///This can be used to temporarily limit the processing to only the most important jobs.
     ///To only enable processing for important jobs, call setNeededPriority(0).
     ///This should only be used to temporarily alter the processing. A progress-bar
     ///will still be shown for the not yet processed jobs.
     void setNeededPriority(int priority);
     ///Disables all processing of new jobs, equivalent to setNeededPriority(BestPriority)
     void disableProcessing();
     ///Enables all processing of new jobs, equivalent to setNeededPriority(WorstPriority)
     void enableProcessing();
 
     ///Returns true if the given url is queued for parsing
     bool isQueued(const IndexedString& url) const;
 
     ///Retrieve the current priority for the given URL.
     ///You need to check whether @param url is queued before calling this function.
     int priorityForDocument(const IndexedString& url) const;
 
     ///Returns the number of queued jobs (not yet running nor submitted to ThreadWeaver)
     int queuedCount() const;
 
     ///Returns true if there are no jobs running nor queued anywhere
     bool isIdle() const;
 
     void documentClosed(KDevelop::IDocument*);
     void documentLoaded(KDevelop::IDocument*);
     void documentUrlChanged(KDevelop::IDocument*);
 
     void loadSettings();
 
 protected Q_SLOTS:
     void parseComplete(const ThreadWeaver::JobPointer& job);
     void parseProgress(KDevelop::ParseJob*, float value, QString text);
     void startTimer(int delay);
     void aboutToQuit();
+    void updateProgressBar();
 
 private:
     friend class BackgroundParserPrivate;
     class BackgroundParserPrivate *d;
 
 private Q_SLOTS:
     /// Tracking of projects in state of loading.
     void projectAboutToBeOpened(KDevelop::IProject* project);
     void projectOpened(KDevelop::IProject* project);
     void projectOpeningAborted(KDevelop::IProject* project);
 };
 
 }
 #endif
diff --git a/plugins/contextbrowser/contextbrowserview.cpp b/plugins/contextbrowser/contextbrowserview.cpp
index 3460e7432f..2691b9d1c2 100644
--- a/plugins/contextbrowser/contextbrowserview.cpp
+++ b/plugins/contextbrowser/contextbrowserview.cpp
@@ -1,315 +1,311 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * 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 "contextbrowserview.h"
 
 #include <QBoxLayout>
 #include <QIcon>
 #include <QMenu>
 #include <QShowEvent>
 #include <QTextBrowser>
 #include <QToolButton>
 
 #include <KLocalizedString>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include <language/duchain/declaration.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <serialization/indexedstring.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include "contextbrowser.h"
 #include "debug.h"
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/specializationstore.h>
 #include "browsemanager.h"
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <language/interfaces/codecontext.h>
 #include <language/duchain/navigation/abstractdeclarationnavigationcontext.h>
 #include <language/duchain/navigation/useswidget.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iplugincontroller.h>
 
 using namespace KDevelop;
 
 QWidget* ContextBrowserView::createWidget(KDevelop::DUContext* context) {
         m_context = IndexedDUContext(context);
         if(m_context.data()) {
             return m_context.data()->createNavigationWidget(nullptr, nullptr, {}, {}, AbstractNavigationWidget::EmbeddableWidget);
         }
         return nullptr;
 }
 
 KDevelop::IndexedDeclaration ContextBrowserView::declaration() const {
     return m_declaration;
 }
 
 QWidget* ContextBrowserView::createWidget(Declaration* decl, TopDUContext* topContext) {
     m_declaration = IndexedDeclaration(decl);
     return decl->context()->createNavigationWidget(decl, topContext, {}, {}, AbstractNavigationWidget::EmbeddableWidget);
 }
 
 
 void ContextBrowserView::resetWidget()
 {
     if (m_navigationWidget) {
         delete m_navigationWidget;
         m_navigationWidget = nullptr;
     }
 }
 
 void ContextBrowserView::declarationMenu() {
     DUChainReadLocker lock(DUChain::lock());
 
     AbstractNavigationWidget* navigationWidget = dynamic_cast<AbstractNavigationWidget*>(m_navigationWidget.data());
     if(navigationWidget) {
         AbstractDeclarationNavigationContext* navigationContext = dynamic_cast<AbstractDeclarationNavigationContext*>(navigationWidget->context().data());
         if(navigationContext && navigationContext->declaration().data()) {
             KDevelop::DeclarationContext* c = new KDevelop::DeclarationContext(navigationContext->declaration().data());
             lock.unlock();
             QMenu menu;
             QList<ContextMenuExtension> extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions( c );
 
             ContextMenuExtension::populateMenu(&menu, extensions);
             menu.exec(QCursor::pos());
         }
     }
 }
 
 void ContextBrowserView::updateLockIcon(bool checked) {
-    m_lockButton->setIcon(QIcon::fromTheme(checked ? QStringLiteral("document-encrypt") : QStringLiteral("document-decrypt")));
+    m_lockAction->setIcon(QIcon::fromTheme(checked ? QStringLiteral("document-encrypt") : QStringLiteral("document-decrypt")));
 }
 
 ContextBrowserView::ContextBrowserView( ContextBrowserPlugin* plugin, QWidget* parent ) : QWidget(parent), m_plugin(plugin), m_navigationWidget(new QTextBrowser()), m_autoLocked(false) {
     setWindowIcon( QIcon::fromTheme(QStringLiteral("code-context"), windowIcon()) );
 
     m_allowLockedUpdate = false;
 
-    m_buttons = new QHBoxLayout;
-    m_buttons->addStretch();
-    m_declarationMenuButton = new QToolButton();
-    m_declarationMenuButton->setIcon(QIcon::fromTheme(QStringLiteral("code-class")));
-    m_declarationMenuButton->setToolTip(i18n("Declaration menu"));
-    connect(m_declarationMenuButton, &QToolButton::clicked, this, &ContextBrowserView::declarationMenu);
-    m_buttons->addWidget(m_declarationMenuButton);
-    m_lockButton = new QToolButton();
-    m_lockButton->setCheckable(true);
-    m_lockButton->setChecked(false);
-    m_lockButton->setToolTip(i18n("Lock current view"));
-    updateLockIcon(m_lockButton->isChecked());
-    connect(m_lockButton, &QToolButton::toggled, this, &ContextBrowserView::updateLockIcon);
-    m_buttons->addWidget(m_lockButton);
+    m_declarationMenuAction = new QAction(QIcon::fromTheme(QStringLiteral("code-class")), QString(), this);
+    m_declarationMenuAction->setToolTip(i18n("Declaration menu"));
+    connect(m_declarationMenuAction, &QAction::triggered, this, &ContextBrowserView::declarationMenu);
+    addAction(m_declarationMenuAction);
+    m_lockAction = new QAction(this);
+    m_lockAction->setCheckable(true);
+    m_lockAction->setChecked(false);
+    m_lockAction->setToolTip(i18n("Lock current view"));
+    addAction(m_lockAction);
+    updateLockIcon(m_lockAction->isChecked());
+    connect(m_lockAction, &QAction::triggered, this, &ContextBrowserView::updateLockIcon);
 
     m_layout = new QVBoxLayout;
     m_layout->setSpacing(0);
     m_layout->setMargin(0);
-    m_layout->addLayout(m_buttons);
     m_layout->addWidget(m_navigationWidget);
     //m_layout->addStretch();
     setLayout(m_layout);
 
     m_plugin->registerToolView(this);
 }
 
 ContextBrowserView::~ContextBrowserView() {
     m_plugin->unRegisterToolView(this);
 }
 
 void ContextBrowserView::focusInEvent(QFocusEvent* event) {
     //Indicate that we have focus
     qCDebug(PLUGIN_CONTEXTBROWSER) << "got focus";
 //     parentWidget()->setBackgroundRole(QPalette::ToolTipBase);
 /*    m_layout->removeItem(m_buttons);*/
 
     return QWidget::focusInEvent(event);
 }
 
 void ContextBrowserView::focusOutEvent(QFocusEvent* event) {
     qCDebug(PLUGIN_CONTEXTBROWSER) << "lost focus";
 //     parentWidget()->setBackgroundRole(QPalette::Background);
 /*    m_layout->insertLayout(0, m_buttons);
     for(int a = 0; a < m_buttons->count(); ++a) {
         QWidgetItem* item = dynamic_cast<QWidgetItem*>(m_buttons->itemAt(a));
     }*/
     QWidget::focusOutEvent(event);
 }
 
 bool ContextBrowserView::event(QEvent* event) {
     QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(event);
 
     if(hasFocus() && keyEvent) {
         AbstractNavigationWidget* navigationWidget = dynamic_cast<AbstractNavigationWidget*>(m_navigationWidget.data());
         if(navigationWidget && event->type() == QEvent::KeyPress) {
             int key = keyEvent->key();
             if(key == Qt::Key_Left)
                 navigationWidget->previous();
             if(key == Qt::Key_Right)
                 navigationWidget->next();
             if(key == Qt::Key_Up)
                 navigationWidget->up();
             if(key == Qt::Key_Down)
                 navigationWidget->down();
             if(key == Qt::Key_Return || key == Qt::Key_Enter)
                 navigationWidget->accept();
 
 
             if(key == Qt::Key_L)
-                m_lockButton->toggle();
+                m_lockAction->toggle();
         }
     }
     return QWidget::event(event);
 }
 
 void ContextBrowserView::showEvent(QShowEvent* event)
 {
     DUChainReadLocker lock(DUChain::lock(), 200);
     if (!lock.locked()) {
         QWidget::showEvent(event);
         return;
     }
 
     TopDUContext* top = m_lastUsedTopContext.data();
     if(top && m_navigationWidgetDeclaration.isValid() && m_navigationWidgetDeclaration.getDeclaration(top)) {
         if(top) {
             //Update the navigation-widget
             Declaration* decl = m_navigationWidgetDeclaration.getDeclaration(top);
             setDeclaration(decl, top, true);
         }
     }
     QWidget::showEvent(event);
 }
 
 bool ContextBrowserView::isLocked() const {
     bool isLocked;
     if (m_allowLockedUpdate) {
         isLocked = false;
     } else {
-        isLocked = m_lockButton->isChecked();
+        isLocked = m_lockAction->isChecked();
     }
     return isLocked;
 }
 
 void ContextBrowserView::updateMainWidget(QWidget* widget)
 {
     if (widget) {
         setUpdatesEnabled(false);
         qCDebug(PLUGIN_CONTEXTBROWSER) << "";
         resetWidget();
         m_navigationWidget = widget;
         m_layout->insertWidget(1, widget, 1);
         m_allowLockedUpdate = false;
         setUpdatesEnabled(true);
         if (widget->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("contextChanged(bool,bool)")) != -1) {
             connect(widget, SIGNAL(contextChanged(bool,bool)), this, SLOT(navigationContextChanged(bool,bool)));
         }
     }
 }
 
 void ContextBrowserView::navigationContextChanged(bool wasInitial, bool isInitial)
 {
-    if(wasInitial && !isInitial && !m_lockButton->isChecked())
+    if(wasInitial && !isInitial && !m_lockAction->isChecked())
     {
         m_autoLocked = true;
-        m_lockButton->setChecked(true);
+        m_lockAction->setChecked(true);
     }else if(!wasInitial && isInitial && m_autoLocked)
     {
         m_autoLocked = false;
-        m_lockButton->setChecked(false);
+        m_lockAction->setChecked(false);
     }else if(isInitial) {
         m_autoLocked = false;
     }
 }
 
 void ContextBrowserView::setDeclaration(KDevelop::Declaration* decl, KDevelop::TopDUContext* topContext, bool force) {
     m_lastUsedTopContext = IndexedTopDUContext(topContext);
 
     if(isLocked() && (!m_navigationWidget.data() || !isVisible()))
     {
         // Automatically remove the locked state if the view is not visible or the widget was deleted,
         // because the locked state has side-effects on other navigation functionality.
         m_autoLocked = false;
-        m_lockButton->setChecked(false);
+        m_lockAction->setChecked(false);
     }
 
     if(m_navigationWidgetDeclaration == decl->id() && !force)
         return;
 
     m_navigationWidgetDeclaration = decl->id();
 
     if (!isLocked() && (isVisible() || force)) {  // NO-OP if toolview is hidden, for performance reasons
 
         QWidget* w = createWidget(decl, topContext);
         updateMainWidget(w);
     }
 }
 
 KDevelop::IndexedDeclaration ContextBrowserView::lockedDeclaration() const {
-    if(m_lockButton->isChecked())
+    if(m_lockAction->isChecked())
         return declaration();
     else
         return KDevelop::IndexedDeclaration();
 }
 
 void ContextBrowserView::allowLockedUpdate() {
     m_allowLockedUpdate = true;
 }
 
 void ContextBrowserView::setNavigationWidget(QWidget* widget) {
     updateMainWidget(widget);
 }
 
 void ContextBrowserView::setContext(KDevelop::DUContext* context) {
     if(!context)
         return;
 
     m_lastUsedTopContext = IndexedTopDUContext(context->topContext());
 
     if(context->owner()) {
         if(context->owner()->id() == m_navigationWidgetDeclaration)
             return;
         m_navigationWidgetDeclaration = context->owner()->id();
     }else{
         m_navigationWidgetDeclaration = DeclarationId();
     }
 
     if (!isLocked() && isVisible()) { // NO-OP if toolview is hidden, for performance reasons
 
         QWidget* w = createWidget(context);
         updateMainWidget(w);
     }
 }
 
 void ContextBrowserView::setSpecialNavigationWidget(QWidget* widget) {
     if (!isLocked() && isVisible()) {
         Q_ASSERT(widget);
         updateMainWidget(widget);
     } else if(widget) {
         widget->deleteLater();
     }
 }
 
diff --git a/plugins/contextbrowser/contextbrowserview.h b/plugins/contextbrowser/contextbrowserview.h
index 03a57c2870..dcb76daca0 100644
--- a/plugins/contextbrowser/contextbrowserview.h
+++ b/plugins/contextbrowser/contextbrowserview.h
@@ -1,114 +1,114 @@
 /*
   * This file is part of KDevelop
  *
  * Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * 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_PLUGIN_CONTEXTBROWSERVIEW_H
 #define KDEVPLATFORM_PLUGIN_CONTEXTBROWSERVIEW_H
 
 #include <QWidget>
 #include <QVector>
 #include <QPointer>
 
 #include <language/duchain/topducontext.h>
 #include <language/editor/documentcursor.h>
 #include <serialization/indexedstring.h>
 
 class ContextBrowserPlugin;
 class QVBoxLayout;
 class QHBoxLayout;
-class QToolButton;
+class QAction;
 class QCheckBox;
 class QMenu;
 class KComboBox;
 
 namespace KDevelop {
 class IDocument;
 }
 
 class ContextBrowserView : public QWidget {
     Q_OBJECT
     public:
         ContextBrowserView( ContextBrowserPlugin*, QWidget* parent );
         ~ContextBrowserView() override;
 
         //duchain must be locked
         void setContext(KDevelop::DUContext* context);
         void setDeclaration(KDevelop::Declaration* decl, KDevelop::TopDUContext* topContext, bool force = false);
         void setSpecialNavigationWidget(QWidget*);
         void updateMainWidget(QWidget*);
 
         /** Allows a single update of the view even if in locked state.
           * This is needed to browse while the locked button is checked. */
         void allowLockedUpdate();
 
         ///Returns the currently locked declaration, or invalid of none is locked atm.
         KDevelop::IndexedDeclaration lockedDeclaration() const;
 
         void setNavigationWidget(QWidget* widget);
         
         QWidget* navigationWidget() {
             return m_navigationWidget;
         }
         
         //duchain must be locked
         QWidget* createWidget(KDevelop::DUContext* context);
         
         //duchain must be locked
         QWidget* createWidget(KDevelop::Declaration* decl, KDevelop::TopDUContext* topContext);
 
         KDevelop::IndexedDeclaration declaration() const;
 
         ///Returns whether the view is currently locked
         bool isLocked() const;
         
     private Q_SLOTS:
         void updateLockIcon(bool); 
         void declarationMenu();
         void navigationContextChanged(bool wasInitial, bool isInitial);
 
     private:
         void showEvent(QShowEvent* event) override;
         bool event(QEvent* event) override;
         
         void focusInEvent(QFocusEvent* event) override;
         void focusOutEvent(QFocusEvent* event) override;
         void resetWidget();
 
     private:
         
         KDevelop::IndexedDeclaration m_declaration;
         
         ContextBrowserPlugin* m_plugin;
         QVBoxLayout* m_layout;
-        QToolButton* m_lockButton;
-        QToolButton* m_declarationMenuButton;
+        QAction* m_lockAction;
+        QAction* m_declarationMenuAction;
         QHBoxLayout* m_buttons;
 
         QPointer<QWidget> m_navigationWidget;
         KDevelop::DeclarationId m_navigationWidgetDeclaration;
         bool m_allowLockedUpdate;
         KDevelop::IndexedTopDUContext m_lastUsedTopContext;
 
         KDevelop::IndexedDUContext m_context;
         // Whether the lock-button was activated automatically due to user navigation
         bool m_autoLocked;
 };
 
 #endif
diff --git a/shell/mainwindow.cpp b/shell/mainwindow.cpp
index 4abc2a3323..016fc573d0 100644
--- a/shell/mainwindow.cpp
+++ b/shell/mainwindow.cpp
@@ -1,473 +1,473 @@
 /* This file is part of the KDevelop project
 Copyright 2002 Falk Brettschneider <falkbr@kdevelop.org>
 Copyright 2003 John Firebaugh <jfirebaugh@kde.org>
 Copyright 2006 Adam Treat <treat@kde.org>
 Copyright 2006, 2007 Alexander Dymo <adymo@kdevelop.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 "mainwindow.h"
 #include "mainwindow_p.h"
 
 #include <QDBusConnection>
 #include <QDomDocument>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QMenu>
 #include <QMenuBar>
 #include <QMimeData>
 #include <QUrl>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KShortcutsDialog>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <KTextEditor/MainWindow>
 #include <KWindowSystem>
 #include <KXMLGUIFactory>
 #include <kparts_version.h>
 
 #include <sublime/area.h>
 #include "shellextension.h"
 #include "partcontroller.h"
 #include "plugincontroller.h"
 #include "projectcontroller.h"
 #include "uicontroller.h"
 #include "documentcontroller.h"
 #include "debugcontroller.h"
 #include "workingsetcontroller.h"
 #include "sessioncontroller.h"
 #include "sourceformattercontroller.h"
 #include "areadisplay.h"
 #include "project.h"
 #include "debug.h"
 #include "uiconfig.h"
 
 #include <interfaces/isession.h>
 #include <interfaces/iprojectcontroller.h>
 #include <sublime/view.h>
 #include <sublime/document.h>
 #include <sublime/urldocument.h>
 #include <sublime/container.h>
 #include <util/path.h>
 #include <util/widgetcolorizer.h>
 
 using namespace KDevelop;
 
 namespace {
 
 QColor defaultColor(const QPalette& palette)
 {
     return palette.foreground().color();
 }
 
 QColor colorForDocument(const QUrl& url, const QPalette& palette, const QColor& defaultColor)
 {
     auto project = Core::self()->projectController()->findProjectForUrl(url);
     if (!project)
         return defaultColor;
 
     return WidgetColorizer::colorForId(qHash(project->path()), palette);
 }
 
 }
 
 void MainWindow::applyMainWindowSettings(const KConfigGroup& config)
 {
     if(!d->changingActiveView())
         KXmlGuiWindow::applyMainWindowSettings(config);
 }
 
 void MainWindow::createGUI(KParts::Part* part)
 {
     //TODO remove if-clause once KF5 >= 5.24 is required
 #if KPARTS_VERSION_MINOR >= 24
     Sublime::MainWindow::setWindowTitleHandling(false);
     Sublime::MainWindow::createGUI(part);
 #else
     Sublime::MainWindow::createGUI(part);
     if (part) {
         // Don't let the Part control the main window caption -- we take care of that
         disconnect(part, SIGNAL(setWindowCaption(QString)),
                    this, SLOT(setCaption(QString)));
     }
 #endif
 }
 
 void MainWindow::initializeCorners()
 {
     const KConfigGroup cg = KSharedConfig::openConfig()->group( "UiSettings" );
     const int bottomleft = cg.readEntry( "BottomLeftCornerOwner", 0 );
     const int bottomright = cg.readEntry( "BottomRightCornerOwner", 0 );
     qCDebug(SHELL) << "Bottom Left:" << bottomleft;
     qCDebug(SHELL) << "Bottom Right:" << bottomright;
 
     // 0 means vertical dock (left, right), 1 means horizontal dock( top, bottom )
     if( bottomleft == 0 )
         setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
     else if( bottomleft == 1 )
         setCorner( Qt::BottomLeftCorner, Qt::BottomDockWidgetArea );
 
     if( bottomright == 0 )
         setCorner( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
     else if( bottomright == 1 )
         setCorner( Qt::BottomRightCorner, Qt::BottomDockWidgetArea );
 }
 
 MainWindow::MainWindow( Sublime::Controller *parent, Qt::WindowFlags flags )
         : Sublime::MainWindow( parent, flags )
 {
     QDBusConnection::sessionBus().registerObject( QStringLiteral("/kdevelop/MainWindow"),
         this, QDBusConnection::ExportScriptableSlots );
 
     setAcceptDrops( true );
     initializeCorners();
 
     setObjectName( QStringLiteral("MainWindow") );
     d = new MainWindowPrivate(this);
 
     setStandardToolBarMenuEnabled( true );
     d->setupActions();
 
     if( !ShellExtension::getInstance()->xmlFile().isEmpty() )
     {
         setXMLFile( ShellExtension::getInstance() ->xmlFile() );
     }
 
     menuBar()->setCornerWidget(new AreaDisplay(this), Qt::TopRightCorner);
 }
 
 MainWindow::~ MainWindow()
 {
     if (memberList().count() == 1) {
         // We're closing down...
         Core::self()->shutdown();
     }
 
     delete d;
 }
 
 KTextEditorIntegration::MainWindow *MainWindow::kateWrapper() const
 {
     return d->kateWrapper();
 }
 
 void MainWindow::ensureVisible()
 {
     if (isMinimized()) {
         if (isMaximized()) {
             showMaximized();
         } else {
             showNormal();
         }
     }
     KWindowSystem::forceActiveWindow(winId());
 }
 
 QAction* MainWindow::createCustomElement(QWidget* parent, int index, const QDomElement& element)
 {
     QAction* before = nullptr;
     if (index > 0 && index < parent->actions().count())
         before = parent->actions().at(index);
 
     //KDevelop needs to ensure that separators defined as <Separator style="visible" />
     //are always shown in the menubar. For those, we create special disabled actions
     //instead of calling QMenuBar::addSeparator() because menubar separators are ignored
     if (element.tagName().toLower() == QLatin1String("separator")
             && element.attribute(QStringLiteral("style")) == QLatin1String("visible")) {
         if ( QMenuBar* bar = qobject_cast<QMenuBar*>( parent ) ) {
             QAction *separatorAction = new QAction(QStringLiteral("|"), this);
             bar->insertAction( before, separatorAction );
             separatorAction->setDisabled(true);
             return separatorAction;
         }
     }
 
     return KXMLGUIBuilder::createCustomElement(parent, index, element);
 }
 
 void MainWindow::dragEnterEvent( QDragEnterEvent* ev )
 {
     if( ev->mimeData()->hasFormat( QStringLiteral("text/uri-list") ) && ev->mimeData()->hasUrls() )
     {
         ev->acceptProposedAction();
     }
 }
 
 void MainWindow::dropEvent( QDropEvent* ev )
 {
     Sublime::View* dropToView = viewForPosition(mapToGlobal(ev->pos()));
     if(dropToView)
         activateView(dropToView);
 
     foreach( const QUrl& u, ev->mimeData()->urls() )
     {
         Core::self()->documentController()->openDocument( u );
     }
     ev->acceptProposedAction();
 }
 
 void MainWindow::loadSettings()
 {
     qCDebug(SHELL) << "Loading Settings";
     initializeCorners();
 
     updateAllTabColors();
 
     Sublime::MainWindow::loadSettings();
 }
 
 void MainWindow::configureShortcuts()
 {
     ///Workaround for a problem with the actions: Always start the shortcut-configuration in the first mainwindow, then propagate the updated
     ///settings into the other windows
 
 
 // We need to bring up the shortcut dialog ourself instead of
 //      Core::self()->uiControllerInternal()->mainWindows()[0]->guiFactory()->configureShortcuts();
 // so we can connect to the saved() signal to propagate changes in the editor shortcuts
 
    KShortcutsDialog dlg(KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsAllowed, this);
     foreach (KXMLGUIClient *client, Core::self()->uiControllerInternal()->mainWindows()[0]->guiFactory()->clients())
     {
         if(client && !client->xmlFile().isEmpty())
             dlg.addCollection( client->actionCollection() );
     }
 
     connect(&dlg, &KShortcutsDialog::saved, this, &MainWindow::shortcutsChanged);
     dlg.configure(true);
 
     QMap<QString, QKeySequence> shortcuts;
     foreach(KXMLGUIClient* client, Core::self()->uiControllerInternal()->mainWindows()[0]->guiFactory()->clients()) {
         foreach(QAction* action, client->actionCollection()->actions()) {
             if(!action->objectName().isEmpty()) {
                 shortcuts[action->objectName()] = action->shortcut();
             }
         }
     }
 
     for(int a = 1; a < Core::self()->uiControllerInternal()->mainWindows().size(); ++a) {
         foreach(KXMLGUIClient* client, Core::self()->uiControllerInternal()->mainWindows()[a]->guiFactory()->clients()) {
             foreach(QAction* action, client->actionCollection()->actions()) {
                 qCDebug(SHELL) << "transferring setting shortcut for" << action->objectName();
                 if(shortcuts.contains(action->objectName())) {
                     action->setShortcut(shortcuts[action->objectName()]);
                 }
             }
         }
     }
 
 }
 
 void MainWindow::shortcutsChanged()
 {
     KTextEditor::View *activeClient = Core::self()->documentController()->activeTextDocumentView();
     if(!activeClient)
         return;
 
     foreach(IDocument * doc, Core::self()->documentController()->openDocuments()) {
         KTextEditor::Document *textDocument = doc->textDocument();
         if (textDocument) {
             foreach(KTextEditor::View *client, textDocument->views()) {
                 if (client != activeClient) {
                     client->reloadXML();
                 }
             }
         }
     }
 }
 
 
 void MainWindow::initialize()
 {
     KStandardAction::keyBindings(this, SLOT(configureShortcuts()), actionCollection());
     setupGUI( KXmlGuiWindow::ToolBar | KXmlGuiWindow::Create | KXmlGuiWindow::Save );
 
     Core::self()->partController()->addManagedTopLevelWidget(this);
     qCDebug(SHELL) << "Adding plugin-added connection";
 
     connect( Core::self()->pluginController(), &IPluginController::pluginLoaded,
              d, &MainWindowPrivate::addPlugin);
     connect( Core::self()->pluginController(), &IPluginController::pluginUnloaded,
              d, &MainWindowPrivate::removePlugin);
     connect( Core::self()->partController(), &IPartController::activePartChanged,
         d, &MainWindowPrivate::activePartChanged);
     connect( this, &MainWindow::activeViewChanged,
         d, &MainWindowPrivate::changeActiveView);
 
     foreach(IPlugin* plugin, Core::self()->pluginController()->loadedPlugins())
         d->addPlugin(plugin);
 
     guiFactory()->addClient(Core::self()->sessionController());
     guiFactory()->addClient(Core::self()->sourceFormatterControllerInternal());
 
     // Needed to re-plug the actions from the sessioncontroller as xmlguiclients don't
     // seem to remember which actions where plugged in.
     Core::self()->sessionController()->updateXmlGuiActionList();
 
     d->setupGui();
 
     //Queued so we process it with some delay, to make sure the rest of the UI has already adapted
     connect(Core::self()->documentController(), &IDocumentController::documentActivated, this, &MainWindow::updateCaption, Qt::QueuedConnection);
     connect(Core::self()->documentController(), &IDocumentController::documentActivated, this, &MainWindow::updateActiveDocumentConnection, Qt::QueuedConnection);
     connect(Core::self()->documentController(), &IDocumentController::documentClosed, this, &MainWindow::updateCaption, Qt::QueuedConnection);
     connect(Core::self()->documentController(), &IDocumentController::documentUrlChanged, this, &MainWindow::updateCaption, Qt::QueuedConnection);
     connect(Core::self()->sessionController()->activeSession(), &ISession::sessionUpdated, this, &MainWindow::updateCaption);
 
-    connect(Core::self()->documentController(), &IDocumentController::documentOpened, this, &MainWindow::updateTabColor, Qt::QueuedConnection);
-    connect(Core::self()->documentController(), &IDocumentController::documentUrlChanged, this, &MainWindow::updateTabColor, Qt::QueuedConnection);
+    connect(Core::self()->documentController(), &IDocumentController::documentOpened, this, &MainWindow::updateTabColor);
+    connect(Core::self()->documentController(), &IDocumentController::documentUrlChanged, this, &MainWindow::updateTabColor);
     connect(this, &Sublime::MainWindow::viewAdded, this, &MainWindow::updateAllTabColors);
     connect(Core::self()->projectController(), &ProjectController::projectOpened, this, &MainWindow::updateAllTabColors, Qt::QueuedConnection);
 
     updateCaption();
 }
 
 void MainWindow::cleanup()
 {
 }
 
 void MainWindow::setVisible( bool visible )
 {
     KXmlGuiWindow::setVisible( visible );
     emit finishedLoading();
 }
 
 bool MainWindow::queryClose()
 {
     if (!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(this, IDocument::Default))
         return false;
 
     return Sublime::MainWindow::queryClose();
 }
 
 void MainWindow::updateActiveDocumentConnection(IDocument* document)
 {
     disconnect(d->activeDocumentReadWriteConnection);
     if (auto textDocument = document->textDocument()) {
         d->activeDocumentReadWriteConnection = connect(textDocument, &KTextEditor::Document::readWriteChanged,
                                                        this, &MainWindow::updateCaption);
     }
 }
 
 void MainWindow::updateCaption()
 {
     const auto activeSession = Core::self()->sessionController()->activeSession();
     QString title = activeSession ? activeSession->description() : QString();
 
     if(area()->activeView())
     {
         if(!title.isEmpty())
             title += QLatin1String(" - [ ");
 
         Sublime::Document* doc = area()->activeView()->document();
         Sublime::UrlDocument* urlDoc = dynamic_cast<Sublime::UrlDocument*>(doc);
         if(urlDoc)
             title += Core::self()->projectController()->prettyFileName(urlDoc->url(), KDevelop::IProjectController::FormatPlain);
         else
             title += doc->title();
 
         auto activeDocument = Core::self()->documentController()->activeDocument();
         if (activeDocument && activeDocument->textDocument() && !activeDocument->textDocument()->isReadWrite())
             title += i18n(" (read only)");
 
         title += QLatin1String(" ]");
     }
 
     setCaption(title);
 }
 
 void MainWindow::updateAllTabColors()
 {
     auto documentController = Core::self()->documentController();
     if (!documentController)
         return;
 
     const auto defaultColor = ::defaultColor(palette());
     if (UiConfig::colorizeByProject()) {
         QHash<const Sublime::View*, QColor> viewColors;
         foreach (auto container, containers()) {
             auto views = container->views();
             viewColors.reserve(views.size());
             viewColors.clear();
             foreach (auto view, views) {
                 const auto urlDoc = qobject_cast<Sublime::UrlDocument*>(view->document());
                 if (urlDoc) {
                     viewColors[view] = colorForDocument(urlDoc->url(), palette(), defaultColor);
                 }
             }
             container->setTabColors(viewColors);
         }
     } else {
         foreach (auto container, containers()) {
             container->resetTabColors(defaultColor);
         }
     }
 }
 
 void MainWindow::updateTabColor(IDocument* doc)
 {
     if (!UiConfig::self()->colorizeByProject())
         return;
 
     const auto color = colorForDocument(doc->url(), palette(), defaultColor(palette()));
     foreach (auto container, containers()) {
         foreach (auto view, container->views()) {
             const auto urlDoc = qobject_cast<Sublime::UrlDocument*>(view->document());
             if (urlDoc && urlDoc->url() == doc->url()) {
                 container->setTabColor(view, color);
             }
         }
     }
 }
 
 void MainWindow::registerStatus(QObject* status)
 {
     d->registerStatus(status);
 }
 
 void MainWindow::initializeStatusBar()
 {
     d->setupStatusBar();
 }
 
 void MainWindow::showErrorMessage(const QString& message, int timeout)
 {
     d->showErrorMessage(message, timeout);
 }
 
 void MainWindow::tabContextMenuRequested(Sublime::View* view, QMenu* menu)
 {
     Sublime::MainWindow::tabContextMenuRequested(view, menu);
     d->tabContextMenuRequested(view, menu);
 }
 
 void MainWindow::tabToolTipRequested(Sublime::View* view, Sublime::Container* container, int tab)
 {
     d->tabToolTipRequested(view, container, tab);
 }
 
 void MainWindow::dockBarContextMenuRequested(Qt::DockWidgetArea area, const QPoint& position)
 {
     d->dockBarContextMenuRequested(area, position);
 }
 
 void MainWindow::newTabRequested()
 {
     Sublime::MainWindow::newTabRequested();
 
     d->fileNew();
 }
diff --git a/shell/projectsourcepage.cpp b/shell/projectsourcepage.cpp
index a3c18b5e02..c625edf714 100644
--- a/shell/projectsourcepage.cpp
+++ b/shell/projectsourcepage.cpp
@@ -1,274 +1,280 @@
 /***************************************************************************
  *   Copyright (C) 2010 by Aleix Pol Gonzalez <aleixpol@kde.org>           *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "projectsourcepage.h"
 #include "ui_projectsourcepage.h"
 #include <interfaces/iplugin.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <vcs/interfaces/ibasicversioncontrol.h>
 #include <vcs/widgets/vcslocationwidget.h>
 #include <vcs/vcsjob.h>
 
 #include <QVBoxLayout>
 
 #include <KColorScheme>
+#include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <interfaces/iprojectprovider.h>
 
 using namespace KDevelop;
 
 static const int FROM_FILESYSTEM_SOURCE_INDEX = 0;
 
 ProjectSourcePage::ProjectSourcePage(const QUrl& initial, QWidget* parent)
     : QWidget(parent)
 {
     m_ui = new Ui::ProjectSourcePage;
     m_ui->setupUi(this);
 
     m_ui->status->setCloseButtonVisible(false);
     m_ui->status->setMessageType(KMessageWidget::Error);
 
     m_ui->workingDir->setUrl(initial);
     m_ui->workingDir->setMode(KFile::Directory);
     m_ui->remoteWidget->setLayout(new QVBoxLayout(m_ui->remoteWidget));
 
     m_ui->sources->addItem(QIcon::fromTheme(QStringLiteral("folder")), i18n("From File System"));
     m_plugins.append(nullptr);
 
     IPluginController* pluginManager = ICore::self()->pluginController();
     QList<IPlugin*> plugins = pluginManager->allPluginsForExtension( QStringLiteral("org.kdevelop.IBasicVersionControl") );
     foreach( IPlugin* p, plugins )
     {
         m_plugins.append(p);
         m_ui->sources->addItem(QIcon::fromTheme(pluginManager->pluginInfo(p).iconName()), p->extension<IBasicVersionControl>()->name());
     }
 
     plugins = pluginManager->allPluginsForExtension( QStringLiteral("org.kdevelop.IProjectProvider") );
     foreach( IPlugin* p, plugins )
     {
         m_plugins.append(p);
         m_ui->sources->addItem(QIcon::fromTheme(pluginManager->pluginInfo(p).iconName()), p->extension<IProjectProvider>()->name());
     }
 
     connect(m_ui->workingDir, &KUrlRequester::textChanged, this, &ProjectSourcePage::reevaluateCorrection);
     connect(m_ui->sources, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ProjectSourcePage::setSourceIndex);
     connect(m_ui->get, &QPushButton::clicked, this, &ProjectSourcePage::checkoutVcsProject);
 
     emit isCorrect(false);
 
     setSourceIndex(FROM_FILESYSTEM_SOURCE_INDEX);
 
-    if(!m_plugins.isEmpty())
-        m_ui->sources->setCurrentIndex(1);
+    const int defaultIndex = m_plugins.isEmpty() ? 0 : 1; // "From File System" is quite unlikely to what you want...
+    KConfigGroup configGroup = KSharedConfig::openConfig()->group("Providers");
+    const int lastCurrentIndex = configGroup.readEntry("LastProviderIndex", defaultIndex);
+    m_ui->sources->setCurrentIndex(qBound(0, lastCurrentIndex, m_ui->sources->count() - 1));
 }
 
 ProjectSourcePage::~ProjectSourcePage()
 {
+    KConfigGroup configGroup = KSharedConfig::openConfig()->group("Providers");
+    configGroup.writeEntry("LastProviderIndex", m_ui->sources->currentIndex());
+
     delete m_ui;
 }
 
 void ProjectSourcePage::setSourceIndex(int index)
 {
     m_locationWidget = nullptr;
     m_providerWidget = nullptr;
     QLayout* remoteWidgetLayout = m_ui->remoteWidget->layout();
     QLayoutItem *child;
     while ((child = remoteWidgetLayout->takeAt(0)) != nullptr) {
         delete child->widget();
         delete child;
     }
 
     IBasicVersionControl* vcIface = vcsPerIndex(index);
     IProjectProvider* providerIface;
     bool found=false;
     if(vcIface) {
         found=true;
         m_locationWidget=vcIface->vcsLocation(m_ui->sourceBox);
         connect(m_locationWidget, &VcsLocationWidget::changed, this, &ProjectSourcePage::locationChanged);
 
         remoteWidgetLayout->addWidget(m_locationWidget);
     } else {
         providerIface = providerPerIndex(index);
         if(providerIface) {
             found=true;
             m_providerWidget=providerIface->providerWidget(m_ui->sourceBox);
             connect(m_providerWidget, &IProjectProviderWidget::changed, this, &ProjectSourcePage::projectChanged);
 
             remoteWidgetLayout->addWidget(m_providerWidget);
         }
     }
     reevaluateCorrection();
 
     m_ui->sourceBox->setVisible(found);
 }
 
 IBasicVersionControl* ProjectSourcePage::vcsPerIndex(int index)
 {
     IPlugin* p = m_plugins.value(index);
     if(!p)
         return nullptr;
     else
         return p->extension<KDevelop::IBasicVersionControl>();
 }
 
 IProjectProvider* ProjectSourcePage::providerPerIndex(int index)
 {
     IPlugin* p = m_plugins.value(index);
     if(!p)
         return nullptr;
     else
         return p->extension<KDevelop::IProjectProvider>();
 }
 
 VcsJob* ProjectSourcePage::jobPerCurrent()
 {
     QUrl url=m_ui->workingDir->url();
     IPlugin* p=m_plugins[m_ui->sources->currentIndex()];
     VcsJob* job=nullptr;
 
     if(IBasicVersionControl* iface=p->extension<IBasicVersionControl>()) {
         Q_ASSERT(iface && m_locationWidget);
         job=iface->createWorkingCopy(m_locationWidget->location(), url);
     } else if(m_providerWidget) {
         job=m_providerWidget->createWorkingCopy(url);
     }
     return job;
 }
 
 void ProjectSourcePage::checkoutVcsProject()
 {
     QUrl url=m_ui->workingDir->url();
     QDir d(url.toLocalFile());
     if(!url.isLocalFile() && !d.exists()) {
         bool corr = d.mkpath(d.path());
         if(!corr) {
             KMessageBox::error(nullptr, i18n("Could not create the directory: %1", d.path()));
             return;
         }
     }
 
     VcsJob* job=jobPerCurrent();
     if (!job) {
         return;
     }
 
     m_ui->sources->setEnabled(false);
     m_ui->sourceBox->setEnabled(false);
     m_ui->workingDir->setEnabled(false);
     m_ui->get->setEnabled(false);
     m_ui->creationProgress->setValue(m_ui->creationProgress->minimum());
     connect(job, &VcsJob::result, this, &ProjectSourcePage::projectReceived);
     // Can't use new signal-slot syntax, KJob::percent is private :/
     connect(job, SIGNAL(percent(KJob*,ulong)), SLOT(progressChanged(KJob*,ulong)));
     connect(job, &VcsJob::infoMessage, this, &ProjectSourcePage::infoMessage);
     ICore::self()->runController()->registerJob(job);
 }
 
 void ProjectSourcePage::progressChanged(KJob*, unsigned long value)
 {
     m_ui->creationProgress->setValue(value);
 }
 
 void ProjectSourcePage::infoMessage(KJob* , const QString& text, const QString& /*rich*/)
 {
     m_ui->creationProgress->setFormat(i18nc("Format of the progress bar text. progress and info",
                                             "%1 : %p%", text));
 }
 
 void ProjectSourcePage::projectReceived(KJob* job)
 {
     if (job->error()) {
         m_ui->creationProgress->setValue(0);
     } else {
         m_ui->creationProgress->setValue(m_ui->creationProgress->maximum());
     }
 
     reevaluateCorrection();
     m_ui->creationProgress->setFormat(QStringLiteral("%p%"));
 }
 
 void ProjectSourcePage::reevaluateCorrection()
 {
     //TODO: Probably we should just ignore remote URL's, I don't think we're ever going
     //to support checking out to remote directories
     const QUrl cwd = m_ui->workingDir->url();
     const QDir dir = cwd.toLocalFile();
 
     // case where we import a project from local file system
     if (m_ui->sources->currentIndex() == FROM_FILESYSTEM_SOURCE_INDEX) {
         emit isCorrect(dir.exists());
         return;
     }
 
     // all other cases where remote locations need to be specified
     bool correct=!cwd.isRelative() && (!cwd.isLocalFile() || QDir(cwd.adjusted(QUrl::RemoveFilename).toLocalFile()).exists());
     emit isCorrect(correct && m_ui->creationProgress->value() == m_ui->creationProgress->maximum());
 
     bool validWidget = ((m_locationWidget && m_locationWidget->isCorrect()) ||
                        (m_providerWidget && m_providerWidget->isCorrect()));
     bool validToCheckout = correct && validWidget; //To checkout, if it exists, it should be an empty dir
     if (validToCheckout && cwd.isLocalFile() && dir.exists()) {
         validToCheckout = dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot).isEmpty();
     }
 
     m_ui->get->setEnabled(validToCheckout);
     m_ui->creationProgress->setEnabled(validToCheckout);
 
     if(!correct)
         setStatus(i18n("You need to specify a valid or nonexistent directory to check out a project"));
     else if(!m_ui->get->isEnabled() && m_ui->workingDir->isEnabled())
         setStatus(i18n("You need to specify a valid project location"));
     else
         clearStatus();
 }
 
 void ProjectSourcePage::locationChanged()
 {
     Q_ASSERT(m_locationWidget);
     if(m_locationWidget->isCorrect()) {
         QString currentUrl = m_ui->workingDir->text();
         currentUrl = currentUrl.left(currentUrl.lastIndexOf('/')+1);
 
         QUrl current = QUrl::fromUserInput(currentUrl + m_locationWidget->projectName());
         m_ui->workingDir->setUrl(current);
     }
     else
         reevaluateCorrection();
 }
 
 void ProjectSourcePage::projectChanged(const QString& name)
 {
     Q_ASSERT(m_providerWidget);
     QString currentUrl = m_ui->workingDir->text();
     currentUrl = currentUrl.left(currentUrl.lastIndexOf('/')+1);
 
     QUrl current = QUrl::fromUserInput(currentUrl + name);
     m_ui->workingDir->setUrl(current);
 }
 
 void ProjectSourcePage::setStatus(const QString& message)
 {
     m_ui->status->setText(message);
     m_ui->status->animatedShow();
 }
 
 void ProjectSourcePage::clearStatus()
 {
     m_ui->status->animatedHide();
 }
 
 QUrl ProjectSourcePage::workingDir() const
 {
     return m_ui->workingDir->url();
 }
diff --git a/sublime/area.cpp b/sublime/area.cpp
index 61ad011238..06566734cb 100644
--- a/sublime/area.cpp
+++ b/sublime/area.cpp
@@ -1,484 +1,485 @@
 /***************************************************************************
  *   Copyright 2006-2007 Alexander Dymo  <adymo@kdevelop.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 Library 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 "area.h"
 
 #include <QMap>
 #include <QList>
 #include <QStringList>
 #include <QAction>
 #include <QPointer>
 
 #include "view.h"
 #include "document.h"
 #include "areaindex.h"
 #include "controller.h"
 #include "sublimedebug.h"
 
 namespace Sublime {
 
 // struct AreaPrivate
 
 struct AreaPrivate {
     AreaPrivate()
         : rootIndex(new RootAreaIndex)
         , currentIndex(rootIndex.data())
         , controller(nullptr)
     {
     }
 
     AreaPrivate(const AreaPrivate &p)
      : title(p.title)
      , rootIndex(new RootAreaIndex(*(p.rootIndex)))
      , currentIndex(rootIndex.data())
      , controller(p.controller)
      , toolViewPositions()
      , desiredToolViews(p.desiredToolViews)
      , shownToolViews(p.shownToolViews)
      , iconName(p.iconName)
      , workingSet(p.workingSet)
      , m_actions(p.m_actions)
     {
     }
 
     ~AreaPrivate()
     {
     }
 
     struct ViewFinder {
         ViewFinder(View *_view): view(_view), index(nullptr) {}
         Area::WalkerMode operator() (AreaIndex *idx) {
             if (idx->hasView(view))
             {
                 index = idx;
                 return Area::StopWalker;
             }
             return Area::ContinueWalker;
         }
         View *view;
         AreaIndex *index;
     };
 
     struct ViewLister {
         Area::WalkerMode operator()(AreaIndex *idx) {
             views += idx->views();
             return Area::ContinueWalker;
         }
         QList<View*> views;
     };
 
     QString title;
 
     QScopedPointer<RootAreaIndex> rootIndex;
     AreaIndex *currentIndex;
     Controller *controller;
 
     QList<View*> toolViews;
     QMap<View *, Sublime::Position> toolViewPositions;
     QMap<QString, Sublime::Position> desiredToolViews;
     QMap<Sublime::Position, QStringList> shownToolViews;
     QString iconName;
     QString workingSet;
     QPointer<View> activeView;
     QList<QAction*> m_actions;
 };
 
 // class Area
 
 Area::Area(Controller *controller, const QString &name, const QString &title)
     :QObject(controller), d( new AreaPrivate() )
 {
     // FIXME: using objectName seems fishy. Introduce areaType method,
     // or some such.
     setObjectName(name);
     d->title = title;
     d->controller = controller;
     d->iconName = QStringLiteral("kdevelop");
     d->workingSet.clear();
     qCDebug(SUBLIME) << "initial working-set:" << d->workingSet;
     initialize();
 }
 
 Area::Area(const Area &area)
     : QObject(area.controller()), d( new AreaPrivate( *(area.d) ) )
 {
     setObjectName(area.objectName());
 
     //clone toolviews
     d->toolViews.clear();
     foreach (View *view, area.toolViews())
         addToolView(view->document()->createView(), area.toolViewPosition(view));
     initialize();
 }
 
 void Area::initialize()
 {
     connect(this, &Area::viewAdded,
             d->controller, &Controller::notifyViewAdded);
     connect(this, &Area::aboutToRemoveView,
             d->controller, &Controller::notifyViewRemoved);
     connect(this, &Area::toolViewAdded,
             d->controller, &Controller::notifyToolViewAdded);
     connect(this, &Area::aboutToRemoveToolView,
             d->controller, &Controller::notifyToolViewRemoved);
     connect(this, &Area::toolViewMoved,
             d->controller, &Controller::toolViewMoved);
 
     /* In theory, ownership is passed to us, so should not bother detecting
     deletion outside.  */
     // Functor will be called after destructor has run -> capture controller pointer by value
     // otherwise we crash because we access the already freed pointer this->d
     auto controller = d->controller;
     connect(this, &Area::destroyed, controller,
             [controller] (QObject* obj) { controller->removeArea(static_cast<Area*>(obj)); });
 }
 
 Area::~Area()
 {
     delete d;
 }
 
 View* Area::activeView()
 {
     return d->activeView.data();
 }
 
 void Area::setActiveView(View* view)
 {
     d->activeView = view;
 }
 
 void Area::addView(View *view, AreaIndex *index, View *after)
 {
     //View *after = 0;
     if (!after  &&  controller()->openAfterCurrent()) {
         after = activeView();
     }
     index->add(view, after);
     connect(view, &View::positionChanged, this, &Area::positionChanged);
     qCDebug(SUBLIME) << "view added in" << this;
     connect(this, &Area::destroyed, view, &View::deleteLater);
     emit viewAdded(index, view);
 }
 
 void Area::addView(View *view, View *after)
 {
     AreaIndex *index = d->currentIndex;
     if (after)
     {
         AreaIndex *i = indexOf(after);
         if (i)
             index = i;
     }
     addView(view, index);
 }
 
 void Area::addView(View *view, View *viewToSplit, Qt::Orientation orientation)
 {
     AreaIndex *indexToSplit = indexOf(viewToSplit);
     addView(view, indexToSplit, orientation);
 }
 
 void Area::addView(View* view, AreaIndex* indexToSplit, Qt::Orientation orientation)
 {
     indexToSplit->split(view, orientation);
     emit viewAdded(indexToSplit, view);
     connect(this, &Area::destroyed, view, &View::deleteLater);
 }
 
 View* Area::removeView(View *view)
 {
     AreaIndex *index = indexOf(view);
-    Q_ASSERT(index);
+    if (!index)
+        return nullptr;
 
     emit aboutToRemoveView(index, view);
     index->remove(view);
     emit viewRemoved(index, view);
 
     return view;
 }
 
 AreaIndex *Area::indexOf(View *view)
 {
     AreaPrivate::ViewFinder f(view);
     walkViews(f, d->rootIndex.data());
     return f.index;
 }
 
 RootAreaIndex *Area::rootIndex() const
 {
     return d->rootIndex.data();
 }
 
 void Area::addToolView(View *view, Position defaultPosition)
 {
     d->toolViews.append(view);
     const QString id = view->document()->documentSpecifier();
     const Position position = d->desiredToolViews.value(id, defaultPosition);
     d->desiredToolViews[id] = position;
     d->toolViewPositions[view] = position;
     emit toolViewAdded(view, position);
 }
 
 void Sublime::Area::raiseToolView(View * toolView)
 {
     emit requestToolViewRaise(toolView);
 }
 
 View* Area::removeToolView(View *view)
 {
     if (!d->toolViews.contains(view))
         return nullptr;
 
     emit aboutToRemoveToolView(view, d->toolViewPositions[view]);
     QString id = view->document()->documentSpecifier();
     qCDebug(SUBLIME) << this << "removed tool view " << id;
     d->desiredToolViews.remove(id);
     d->toolViews.removeAll(view);
     d->toolViewPositions.remove(view);
     return view;
 }
 
 void Area::moveToolView(View *toolView, Position newPosition)
 {
     if (!d->toolViews.contains(toolView))
         return;
 
     QString id = toolView->document()->documentSpecifier();
     d->desiredToolViews[id] = newPosition;
     d->toolViewPositions[toolView] = newPosition;
     emit toolViewMoved(toolView, newPosition);
 }
 
 QList<View*> &Area::toolViews() const
 {
     return d->toolViews;
 }
 
 Position Area::toolViewPosition(View *toolView) const
 {
     return d->toolViewPositions[toolView];
 }
 
 Controller *Area::controller() const
 {
     return d->controller;
 }
 
 QList<View*> Sublime::Area::views()
 {
     AreaPrivate::ViewLister lister;
     walkViews(lister, d->rootIndex.data());
     return lister.views;
 }
 
 QString Area::title() const
 {
     return d->title;
 }
 
 void Area::setTitle(const QString &title)
 {
     d->title = title;
 }
 
 void Area::save(KConfigGroup& group) const
 {
     QStringList desired;
     QMap<QString, Sublime::Position>::iterator i, e;
     for (i = d->desiredToolViews.begin(), e = d->desiredToolViews.end(); i != e; ++i)
     {
         desired << i.key() + ':' + QString::number(static_cast<int>(i.value()));
     }
     group.writeEntry("desired views", desired);
     qCDebug(SUBLIME) << "save " << this << "wrote" << group.readEntry("desired views", "");
     group.writeEntry("view on left", shownToolViews(Sublime::Left));
     group.writeEntry("view on right", shownToolViews(Sublime::Right));
     group.writeEntry("view on top", shownToolViews(Sublime::Top));
     group.writeEntry("view on bottom", shownToolViews(Sublime::Bottom));
     group.writeEntry("working set", d->workingSet);
 }
 
 void Area::load(const KConfigGroup& group)
 {
     qCDebug(SUBLIME) << "loading areas config";
     d->desiredToolViews.clear();
     QStringList desired = group.readEntry("desired views", QStringList());
     foreach (const QString &s, desired)
     {
         int i = s.indexOf(':');
         if (i != -1)
         {
             QString id = s.left(i);
             int pos_i = s.midRef(i+1).toInt();
             Sublime::Position pos = static_cast<Sublime::Position>(pos_i);
             if (pos != Sublime::Left && pos != Sublime::Right && pos != Sublime::Top && pos != Sublime::Bottom)
             {
                 pos = Sublime::Bottom;
             }
 
             d->desiredToolViews[id] = pos;
         }
     }
     setShownToolViews(Sublime::Left, group.readEntry("view on left", QStringList()));
     setShownToolViews(Sublime::Right,
                      group.readEntry("view on right", QStringList()));
     setShownToolViews(Sublime::Top, group.readEntry("view on top", QStringList()));
     setShownToolViews(Sublime::Bottom,
                      group.readEntry("view on bottom", QStringList()));
     setWorkingSet(group.readEntry("working set", d->workingSet));
 }
 
 bool Area::wantToolView(const QString& id)
 {
     return (d->desiredToolViews.contains(id));
 }
 
 void Area::setShownToolViews(Sublime::Position pos, const QStringList& ids)
 {
     d->shownToolViews[pos] = ids;
 }
 
 QStringList Area::shownToolViews(Sublime::Position pos) const
 {
     if (pos == Sublime::AllPositions) {
         QStringList allIds;
         std::for_each(d->shownToolViews.constBegin(), d->shownToolViews.constEnd(), [&](const QStringList& ids) {
             allIds << ids;
         });
         return allIds;
     }
 
     return d->shownToolViews[pos];
 }
 
 void Area::setDesiredToolViews(
     const QMap<QString, Sublime::Position>& desiredToolViews)
 {
     d->desiredToolViews = desiredToolViews;
 }
 
 QString Area::iconName() const
 {
     return d->iconName;
 }
 
 void Area::setIconName(const QString& iconName)
 {
     d->iconName = iconName;
 }
 
 void Area::positionChanged(View *view, int newPos)
 {
     qCDebug(SUBLIME) << view << newPos;
     AreaIndex *index = indexOf(view);
     index->views().move(index->views().indexOf(view), newPos);
 }
 
 
 QString Area::workingSet() const
 {
     return d->workingSet;
 }
 
 
 void Area::setWorkingSet(QString name)
 {
     if(name != d->workingSet) {
         qCDebug(SUBLIME) << this << "setting new working-set" << name;
         QString oldName = d->workingSet;
         emit changingWorkingSet(this, oldName, name);
         d->workingSet = name;
         emit changedWorkingSet(this, oldName, name);
     }
 }
 
 bool Area::closeView(View* view, bool silent)
 {
     QPointer<Document> doc = view->document();
 
     // We don't just delete the view, because if silent is false, we might need to ask the user.
     if(doc && !silent)
     {
         // Do some counting to check whether we need to ask the user for feedback
         qCDebug(SUBLIME) << "Closing view for" << view->document()->documentSpecifier() << "views" << view->document()->views().size() << "in area" << this;
         int viewsInCurrentArea = 0; // Number of views for the same document in the current area
         int viewsInOtherAreas = 0; // Number of views for the same document in other areas
         int viewsInOtherWorkingSets = 0; // Number of views for the same document in areas with different working-set
 
         foreach(View* otherView, doc.data()->views())
         {
             Area* area = controller()->areaForView(otherView);
             if(area == this)
                 viewsInCurrentArea += 1;
             if(!area || (area != this))
                 viewsInOtherAreas += 1;
             if(area && area != this && area->workingSet() != workingSet())
                 viewsInOtherWorkingSets += 1;
         }
 
         if(viewsInCurrentArea == 1 && (viewsInOtherAreas == 0 || viewsInOtherWorkingSets == 0))
         {
             // Time to ask the user for feedback, because the document will be completely closed
             // due to working-set synchronization
             if( !doc.data()->askForCloseFeedback() )
                 return false;
         }
     }
 
     // otherwise we can silently close the view,
     // the document will still have an opened view somewhere
     delete removeView(view);
 
     return true;
 }
 
 void Area::clearViews(bool silent)
 {
     foreach(Sublime::View* view, views()) {
         closeView(view, silent);
     }
 }
 
 void Area::clearDocuments()
 {
     if (views().isEmpty())
         emit clearWorkingSet(this);
     else
         clearViews(true);
 }
 
 QList<QAction*> Area::actions() const
 {
     return d->m_actions;
 }
 
 void Area::addAction(QAction* action)
 {
     Q_ASSERT(!d->m_actions.contains(action));
     connect(action, &QAction::destroyed, this, &Area::actionDestroyed);
     d->m_actions.append(action);
 }
 
 void Area::actionDestroyed(QObject* action)
 {
     d->m_actions.removeAll(qobject_cast<QAction*>(action));
 }
 
 }