diff --git a/kdevplatform/language/util/debuglanguageparserhelper.h b/kdevplatform/language/util/debuglanguageparserhelper.h
index 10ba023948..f644f51e7f 100644
--- a/kdevplatform/language/util/debuglanguageparserhelper.h
+++ b/kdevplatform/language/util/debuglanguageparserhelper.h
@@ -1,240 +1,245 @@
 /* This file is part of KDevelop
 
    Copyright 2010 Milian Wolff <mail@milianw.de>
    Copyright 2014 Kevin Funk <kfunk@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_DEBUGLANGUAGEPARSERHELPER_H
 #define KDEVPLATFORM_DEBUGLANGUAGEPARSERHELPER_H
 
 #include <cstdlib>
 #include <cstdio>
 
 #ifndef Q_OS_WIN
 #include <unistd.h> // for isatty
 #endif
 
 #include <tests/autotestshell.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/problem.h>
 #include <language/codegen/coderepresentation.h>
 #include <tests/testcore.h>
 
 #include <KAboutData>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QCommandLineOption>
 #include <QTextStream>
 
 namespace KDevelopUtils {
 
 
 QTextStream qout(stdout);
 QTextStream qerr(stderr);
 QTextStream qin(stdin);
 
 typedef QString (*TokenTextFunc)(int);
 /**
  * This class is a pure helper to use for binaries that you can
  * run on short snippets of test code or whole files and let
  * it print the generated tokens or AST.
  *
  * It should work fine for any KDevelop-PG-Qt based parser.
  *
  *
  * @tparam SessionT the parse session for your language.
  * @tparam TokenStreamT the token stream for your language, based on KDevPG::TokenStreamBase.
  * @tparam TokenT the token class for your language, based on KDevPG::Token.
  * @tparam LexerT the Lexer for your language.
  * @tparam StartAstT the AST node that is returned from @c SessionT::parse().
  * @tparam DebugVisitorT the debug visitor for your language.
  * @tparam TokenTextT function pointer to the function that returns a string representation for an integral token.
  */
 template<class SessionT, class TokenStreamT, class TokenT, class LexerT,
          class StartAstT, class DebugVisitorT, TokenTextFunc TokenTextT>
 class DebugLanguageParserHelper {
 public:
     DebugLanguageParserHelper(const bool printAst, const bool printTokens)
         : m_printAst(printAst), m_printTokens(printTokens)
     {
         m_session.setDebug(printAst);
     }
 
     /// parse contents of a file
     void parseFile( const QString &fileName )
     {
         if (!m_session.readFile(fileName, "utf-8")) {
             qerr << "Can't open file " << fileName << endl;
             std::exit(255);
         } else {
             qout << "Parsing file " << fileName << endl;
         }
         runSession();
     }
 
     /// parse code directly
     void parseCode( const QString &code )
     {
         m_session.setContents(code);
 
         qout << "Parsing input" << endl;
         runSession();
     }
 
 private:
     /**
      * actually run the parse session
      */
     void runSession()
     {
         if (m_printTokens) {
             TokenStreamT tokenStream;
             LexerT lexer(&tokenStream, m_session.contents());
             int token;
             while ((token = lexer.nextTokenKind())) {
                 TokenT &t = tokenStream.push();
                 t.begin = lexer.tokenBegin();
                 t.end = lexer.tokenEnd();
                 t.kind = token;
                 printToken(token, lexer);
             }
             printToken(token, lexer);
             if ( tokenStream.size() > 0 ) {
                 qint64 line;
                 qint64 column;
                 tokenStream.endPosition(tokenStream.size() - 1, &line, &column);
                 qDebug() << "last token endPosition: line" << line << "column" << column;
             } else {
                 qDebug() << "empty token stream";
             }
         }
 
         StartAstT* ast = 0;
         if (!m_session.parse(&ast)) {
             qerr << "no AST tree could be generated" << endl;
         } else {
             qout << "AST tree successfully generated" << endl;
             if (m_printAst) {
                 DebugVisitorT debugVisitor(m_session.tokenStream(), m_session.contents());
                 debugVisitor.visitStart(ast);
             }
         }
         if (!m_session.problems().isEmpty()) {
             qout << endl << "problems encountered during parsing:" << endl;
             foreach(KDevelop::ProblemPointer p, m_session.problems()) {
                 qout << p->description() << endl;
             }
         } else {
             qout << "no problems encountered during parsing" << endl;
         }
 
         if (!ast) {
             exit(255);
         }
     }
 
     void printToken(int token, const LexerT& lexer) const
     {
         int begin = lexer.tokenBegin();
         int end = lexer.tokenEnd();
         qout << m_session.contents().mid(begin, end - begin + 1).replace('\n', "\\n")
              << ' ' << TokenTextT(token) << endl;
     }
 
     SessionT m_session;
     const bool m_printAst;
     const bool m_printTokens;
 };
 
 template<class ParserT>
 void setupCustomArgs(QCommandLineParser* parser)
-{}
+{
+    Q_UNUSED(parser);
+}
 
 template<class ParserT>
 void setCustomArgs(ParserT* parser, QCommandLineParser* commandLineParser)
-{}
+{
+    Q_UNUSED(parser);
+    Q_UNUSED(commandLineParser);
+}
 
 /// call this after setting up @p aboutData in your @c main() function.
 template<class ParserT>
 int initAndRunParser(KAboutData& aboutData, int argc, char* argv[])
 {
     qout.setCodec("UTF-8");
     qerr.setCodec("UTF-8");
     qin.setCodec("UTF-8");
 
     QApplication app(argc, argv);
 
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     parser.addVersionOption();
     parser.addHelpOption();
 
     aboutData.setupCommandLine(&parser);
 
     parser.addPositionalArgument("files", i18n("files or - to read from STDIN, the latter is the default if nothing is provided"), "[FILE...]");
 
     parser.addOption(QCommandLineOption{QStringList{"a", "print-ast"}, i18n("print generated AST tree")});
     parser.addOption(QCommandLineOption{QStringList{"t", "print-tokens"}, i18n("print generated token stream")});
     parser.addOption(QCommandLineOption{QStringList{"c", "code"}, i18n("code to parse"), "code"});
     setupCustomArgs<ParserT>(&parser);
 
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     QStringList files = parser.positionalArguments();
     bool printAst = parser.isSet("print-ast");
     bool printTokens = parser.isSet("print-tokens");
 
     KDevelop::AutoTestShell::init();
     KDevelop::TestCore::initialize(KDevelop::Core::NoUi);
 
     KDevelop::DUChain::self()->disablePersistentStorage();
     KDevelop::CodeRepresentation::setDiskChangesForbidden(true);
 
     ParserT parserT(printAst, printTokens);
     setCustomArgs(&parserT, &parser);
 
     if (parser.isSet("code")) {
         parserT.parseCode(parser.value("code"));
     } else if (files.isEmpty()) {
         files << "-";
     }
 
     foreach(const QString &fileName, files) {
         if ( fileName == "-" ) {
 #ifndef Q_OS_WIN
             if ( isatty(STDIN_FILENO) ) {
                 qerr << "no STDIN given" << endl;
                 return 255;
             }
 #endif
             parserT.parseCode( qin.readAll().toUtf8() );
         } else {
             parserT.parseFile(fileName);
         }
 
     }
 
     KDevelop::TestCore::shutdown();
 
     return 0;
 }
 }
 
 #endif // KDEVPLATFORM_DEBUGLANGUAGEPARSERHELPER_H
diff --git a/kdevplatform/shell/projectcontroller.cpp b/kdevplatform/shell/projectcontroller.cpp
index ba724c2b26..d78975bb5c 100644
--- a/kdevplatform/shell/projectcontroller.cpp
+++ b/kdevplatform/shell/projectcontroller.cpp
@@ -1,1271 +1,1277 @@
 
 /* This file is part of KDevelop
 Copyright 2006 Adam Treat <treat@kde.org>
 Copyright 2007 Andreas Pakulat <apaku@gmx.de>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #include "projectcontroller.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QDBusConnection>
 #include <QDir>
 #include <QGroupBox>
 #include <QLabel>
 #include <QList>
 #include <QMap>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QSet>
 #include <QTemporaryFile>
 #include <QVBoxLayout>
 #include <QTimer>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KIO/DeleteJob>
 #include <KIO/FileCopyJob>
 #include <KIO/ListJob>
 #include <KIO/StatJob>
 #include <KJobWidgets>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KPassivePopup>
 #include <KRecentFilesAction>
 #include <KSharedConfig>
 #include <KStandardAction>
 
 #include <sublime/area.h>
 #include <interfaces/iplugin.h>
 #include <interfaces/isession.h>
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iselectioncontroller.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <project/projectchangesmodel.h>
 #include <project/projectmodel.h>
 #include <project/projectbuildsetmodel.h>
 #include <projectconfigpage.h>
 #include <language/backgroundparser/parseprojectjob.h>
 #include <interfaces/iruncontroller.h>
 #include <util/scopeddialog.h>
 #include <vcs/widgets/vcsdiffpatchsources.h>
 #include <vcs/widgets/vcscommitdialog.h>
 
 #include "core.h"
 // TODO: Should get rid off this include (should depend on IProject only)
 #include "project.h"
 #include "mainwindow.h"
 #include "shellextension.h"
 #include "plugincontroller.h"
 #include "configdialog.h"
 #include "uicontroller.h"
 #include "documentcontroller.h"
 #include "openprojectdialog.h"
 #include "sessioncontroller.h"
 #include "session.h"
 #include "debug.h"
 
 namespace KDevelop
 {
 
 class ProjectControllerPrivate
 {
 public:
     QList<IProject*> m_projects;
     QMap< IProject*, QList<IPlugin*> > m_projectPlugins;
-    QPointer<KRecentFilesAction> m_recentAction;
+    QPointer<KRecentFilesAction> m_recentProjectsAction;
     Core* m_core;
 //     IProject* m_currentProject;
     ProjectModel* model;
     QPointer<QAction> m_openProject;
     QPointer<QAction> m_fetchProject;
     QPointer<QAction> m_closeProject;
     QPointer<QAction> m_openConfig;
     IProjectDialogProvider* dialog;
     QList<QUrl> m_currentlyOpening; // project-file urls that are being opened
     ProjectController* q;
     ProjectBuildSetModel* buildset;
     bool m_foundProjectFile; //Temporary flag used while searching the hierarchy for a project file
     bool m_cleaningUp; //Temporary flag enabled while destroying the project-controller
     ProjectChangesModel* m_changesModel = nullptr;
     QHash< IProject*, QPointer<KJob> > m_parseJobs; // parse jobs that add files from the project to the background parser.
 
     explicit ProjectControllerPrivate( ProjectController* p )
         : m_core(nullptr), model(nullptr), dialog(nullptr), q(p), buildset(nullptr), m_foundProjectFile(false), m_cleaningUp(false)
     {
     }
 
     void unloadAllProjectPlugins()
     {
         if( m_projects.isEmpty() )
             m_core->pluginControllerInternal()->unloadProjectPlugins();
     }
 
     void projectConfig( QObject * obj )
     {
         if( !obj )
             return;
         Project* proj = qobject_cast<Project*>(obj);
         if( !proj )
             return;
 
         auto cfgDlg = new KDevelop::ConfigDialog(m_core->uiController()->activeMainWindow());
         cfgDlg->setAttribute(Qt::WA_DeleteOnClose);
         cfgDlg->setModal(true);
 
         QVector<KDevelop::ConfigPage*> configPages;
 
         ProjectConfigOptions options;
         options.developerFile = proj->developerFile();
         options.developerTempFile = proj->developerTempFile();
         options.projectTempFile = proj->projectTempFile();
         options.project = proj;
 
         foreach (IPlugin* plugin, findPluginsForProject(proj)) {
             for (int i = 0; i < plugin->perProjectConfigPages(); ++i) {
                 configPages.append(plugin->perProjectConfigPage(i, options, cfgDlg));
             }
         }
 
         std::sort(configPages.begin(), configPages.end(),
                   [](const ConfigPage* a, const ConfigPage* b) {
             return a->name() < b->name();
         });
 
         for (auto page : configPages) {
             cfgDlg->appendConfigPage(page);
         }
 
         QObject::connect(cfgDlg, &ConfigDialog::configSaved, cfgDlg, [this, proj](ConfigPage* page) {
             Q_UNUSED(page)
             Q_ASSERT_X(proj, Q_FUNC_INFO,
                     "ConfigDialog signalled project config change, but no project set for configuring!");
             emit q->projectConfigurationChanged(proj);
         });
         cfgDlg->setWindowTitle(i18n("Configure Project %1", proj->name()));
         QObject::connect(cfgDlg, &KDevelop::ConfigDialog::finished, [proj]() {
             proj->projectConfiguration()->sync();
         });
         cfgDlg->show();
     }
 
     void saveListOfOpenedProjects()
     {
         auto activeSession = Core::self()->activeSession();
         if (!activeSession) {
             return;
         }
 
         QList<QUrl> openProjects;
         openProjects.reserve( m_projects.size() );
 
         foreach( IProject* project, m_projects ) {
             openProjects.append(project->projectFile().toUrl());
         }
 
         activeSession->setContainedProjects( openProjects );
     }
 
     // Recursively collects builder dependencies for a project.
     static void collectBuilders( QList< IProjectBuilder* >& destination, IProjectBuilder* topBuilder, IProject* project )
     {
         QList< IProjectBuilder* > auxBuilders = topBuilder->additionalBuilderPlugins( project );
         destination.append( auxBuilders );
         foreach( IProjectBuilder* auxBuilder, auxBuilders ) {
             collectBuilders( destination, auxBuilder, project );
         }
     }
 
     QVector<IPlugin*> findPluginsForProject( IProject* project ) const
     {
         QList<IPlugin*> plugins = m_core->pluginController()->loadedPlugins();
         QVector<IPlugin*> projectPlugins;
         QList<IProjectBuilder*> buildersForKcm;
         // Important to also include the "top" builder for the project, so
         // projects with only one such builder are kept working. Otherwise the project config
         // dialog is empty for such cases.
         if( IBuildSystemManager* buildSystemManager = project->buildSystemManager() ) {
             buildersForKcm << buildSystemManager->builder();
             collectBuilders( buildersForKcm, buildSystemManager->builder(), project );
         }
 
         foreach(auto plugin, plugins) {
             auto info = m_core->pluginController()->pluginInfo(plugin);
             IProjectFileManager* manager = plugin->extension<KDevelop::IProjectFileManager>();
             if( manager && manager != project->projectFileManager() )
             {
                 // current plugin is a manager but does not apply to given project, skip
                 continue;
             }
             IProjectBuilder* builder = plugin->extension<KDevelop::IProjectBuilder>();
             if ( builder && !buildersForKcm.contains( builder ) )
             {
                 continue;
             }
             qCDebug(SHELL) << "Using plugin" << info.pluginId() << "for project" << project->name();
             projectPlugins << plugin;
         }
 
         return projectPlugins;
     }
 
     void updateActionStates()
     {
         // if only one project loaded, this is always our target
         int itemCount = (m_projects.size() == 1) ? 1 : 0;
 
         if (itemCount == 0) {
             // otherwise base on selection
             ProjectItemContext* itemContext = dynamic_cast<ProjectItemContext*>(ICore::self()->selectionController()->currentSelection());
             if (itemContext) {
                 itemCount = itemContext->items().count();
             }
         }
 
         m_openConfig->setEnabled(itemCount == 1);
         m_closeProject->setEnabled(itemCount > 0);
     }
 
     void openProjectConfig()
     {
         // if only one project loaded, this is our target
         IProject *project = (m_projects.count() == 1) ? m_projects.at(0) : nullptr;
 
         // otherwise base on selection
         if (!project) {
             ProjectItemContext* ctx = dynamic_cast<ProjectItemContext*>(ICore::self()->selectionController()->currentSelection());
             if (ctx && ctx->items().count() == 1) {
                 project = ctx->items().at(0)->project();
             }
         }
 
         if (project) {
             q->configureProject(project);
         }
     }
 
     void closeSelectedProjects()
     {
         QSet<IProject*> projects;
 
         // if only one project loaded, this is our target
         if (m_projects.count() == 1) {
             projects.insert(m_projects.at(0));
         } else {
             // otherwise base on selection
             ProjectItemContext* ctx =  dynamic_cast<ProjectItemContext*>(ICore::self()->selectionController()->currentSelection());
             if (ctx) {
                 foreach (ProjectBaseItem* item, ctx->items()) {
                     projects.insert(item->project());
                 }
             }
         }
 
         foreach (IProject* project, projects) {
             q->closeProject(project);
         }
     }
 
     void importProject(const QUrl& url_)
     {
         QUrl url(url_);
         if (url.isLocalFile()) {
             const QString path = QFileInfo(url.toLocalFile()).canonicalFilePath();
             if (!path.isEmpty()) {
                 url = QUrl::fromLocalFile(path);
             }
         }
 
         if ( !url.isValid() )
         {
             KMessageBox::error(Core::self()->uiControllerInternal()->activeMainWindow(),
                             i18n("Invalid Location: %1", url.toDisplayString(QUrl::PreferLocalFile)));
             return;
         }
 
         if ( m_currentlyOpening.contains(url))
         {
             qCDebug(SHELL) << "Already opening " << url << ". Aborting.";
             KPassivePopup::message( i18n( "Project already being opened"),
                                     i18n( "Already opening %1, not opening again",
                                         url.toDisplayString(QUrl::PreferLocalFile) ),
                                     m_core->uiController()->activeMainWindow() );
             return;
         }
 
         foreach( IProject* project, m_projects )
         {
             if ( url == project->projectFile().toUrl() )
             {
                 if ( dialog->userWantsReopen() )
                 { // close first, then open again by falling through
                     q->closeProject(project);
                 } else { // abort
                     return;
                 }
             }
         }
 
         m_currentlyOpening += url;
 
         m_core->pluginControllerInternal()->loadProjectPlugins();
 
         Project* project = new Project();
         QObject::connect(project, &Project::aboutToOpen,
                          q, &ProjectController::projectAboutToBeOpened);
         if ( !project->open( Path(url) ) )
         {
             m_currentlyOpening.removeAll(url);
             q->abortOpeningProject(project);
             project->deleteLater();
         }
     }
 
     void areaChanged(Sublime::Area* area) {
         KActionCollection* ac = m_core->uiControllerInternal()->defaultMainWindow()->actionCollection();
         ac->action(QStringLiteral("commit_current_project"))->setEnabled(area->objectName() == QLatin1String("code"));
         ac->action(QStringLiteral("commit_current_project"))->setVisible(area->objectName() == QLatin1String("code"));
     }
 };
 
 IProjectDialogProvider::IProjectDialogProvider()
 {}
 
 IProjectDialogProvider::~IProjectDialogProvider()
 {}
 
 ProjectDialogProvider::ProjectDialogProvider(ProjectControllerPrivate* const p) : d(p)
 {}
 
 ProjectDialogProvider::~ProjectDialogProvider()
 {}
 
 bool writeNewProjectFile( const QString& localConfigFile, const QString& name, const QString& createdFrom, const QString& manager )
 {
     KSharedConfigPtr cfg = KSharedConfig::openConfig( localConfigFile, KConfig::SimpleConfig );
     if (!cfg->isConfigWritable(true)) {
         qCDebug(SHELL) << "can't write to configfile";
         return false;
     }
     KConfigGroup grp = cfg->group( "Project" );
     grp.writeEntry( "Name", name );
     grp.writeEntry( "CreatedFrom", createdFrom );
     grp.writeEntry( "Manager", manager );
     cfg->sync();
     return true;
 }
 
 bool writeProjectSettingsToConfigFile(const QUrl& projectFileUrl, OpenProjectDialog* dlg)
 {
     if ( !projectFileUrl.isLocalFile() ) {
         QTemporaryFile tmp;
         if ( !tmp.open() ) {
             return false;
         }
         if ( !writeNewProjectFile( tmp.fileName(), dlg->projectName(), dlg->selectedUrl().fileName(), dlg->projectManager() ) ) {
             return false;
         }
         // explicitly close file before uploading it, see also: https://bugs.kde.org/show_bug.cgi?id=254519
         tmp.close();
 
         auto uploadJob = KIO::file_copy(QUrl::fromLocalFile(tmp.fileName()), projectFileUrl);
         KJobWidgets::setWindow(uploadJob, Core::self()->uiControllerInternal()->defaultMainWindow());
         return uploadJob->exec();
     }
     // Here and above we take .filename() part of the selectedUrl() to make it relative to the project root,
     // thus keeping .kdev file relocatable
     return writeNewProjectFile( projectFileUrl.toLocalFile(), dlg->projectName(), dlg->selectedUrl().fileName(), dlg->projectManager() );
 }
 
 
 bool projectFileExists( const QUrl& u )
 {
     if( u.isLocalFile() )
     {
         return QFileInfo::exists( u.toLocalFile() );
     } else
     {
         auto statJob = KIO::stat(u, KIO::StatJob::DestinationSide, 0, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, Core::self()->uiControllerInternal()->activeMainWindow());
         return statJob->exec();
     }
 }
 
 bool equalProjectFile( const QString& configPath, OpenProjectDialog* dlg )
 {
     KSharedConfigPtr cfg = KSharedConfig::openConfig( configPath, KConfig::SimpleConfig );
     KConfigGroup grp = cfg->group( "Project" );
     QString defaultName = dlg->projectFileUrl().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).fileName();
     return (grp.readEntry( "Name", QString() ) == dlg->projectName() || dlg->projectName() == defaultName) &&
            grp.readEntry( "Manager", QString() ) == dlg->projectManager();
 }
 
 QUrl ProjectDialogProvider::askProjectConfigLocation(bool fetch, const QUrl& startUrl,
                                                      const QUrl& repoUrl, IPlugin* vcsOrProviderPlugin)
 {
     Q_ASSERT(d);
     ScopedDialog<OpenProjectDialog> dlg(fetch, startUrl, repoUrl, vcsOrProviderPlugin,
                                          Core::self()->uiController()->activeMainWindow());
     if(dlg->exec() == QDialog::Rejected) {
         return QUrl();
     }
 
     QUrl projectFileUrl = dlg->projectFileUrl();
     qCDebug(SHELL) << "selected project:" << projectFileUrl << dlg->projectName() << dlg->projectManager();
     if ( dlg->projectManager() == QLatin1String("<built-in>") ) {
         return projectFileUrl;
     }
 
     // controls if existing project file should be saved
     bool writeProjectConfigToFile = true;
     if( projectFileExists( projectFileUrl ) )
     {
         // check whether config is equal
         bool shouldAsk = true;
         if( projectFileUrl == dlg->selectedUrl() )
         {
             if( projectFileUrl.isLocalFile() )
             {
                 shouldAsk = !equalProjectFile( projectFileUrl.toLocalFile(), dlg );
             } else {
                 shouldAsk = false;
 
                 QTemporaryFile tmpFile;
                 if (tmpFile.open()) {
                     auto downloadJob = KIO::file_copy(projectFileUrl, QUrl::fromLocalFile(tmpFile.fileName()));
                     KJobWidgets::setWindow(downloadJob, qApp->activeWindow());
                     if (downloadJob->exec()) {
                         shouldAsk = !equalProjectFile(tmpFile.fileName(), dlg);
                     }
                 }
             }
         }
 
         if ( shouldAsk )
         {
             KGuiItem yes = KStandardGuiItem::yes();
             yes.setText(i18n("Override"));
             yes.setToolTip(i18nc("@info:tooltip", "Continue to open the project and use the just provided project configuration."));
             yes.setIcon(QIcon());
             KGuiItem no = KStandardGuiItem::no();
             no.setText(i18n("Open Existing File"));
             no.setToolTip(i18nc("@info:tooltip", "Continue to open the project but use the existing project configuration."));
             no.setIcon(QIcon());
             KGuiItem cancel = KStandardGuiItem::cancel();
             cancel.setToolTip(i18nc("@info:tooltip", "Cancel and do not open the project."));
             int ret = KMessageBox::questionYesNoCancel(qApp->activeWindow(),
                 i18n("There already exists a project configuration file at %1.\n"
                      "Do you want to override it or open the existing file?", projectFileUrl.toDisplayString(QUrl::PreferLocalFile)),
                 i18n("Override existing project configuration"), yes, no, cancel );
             if ( ret == KMessageBox::No )
             {
                 writeProjectConfigToFile = false;
             } else if ( ret == KMessageBox::Cancel )
             {
                 return QUrl();
             } // else fall through and write new file
         } else {
             writeProjectConfigToFile = false;
         }
     }
 
     if (writeProjectConfigToFile) {
         Path projectConfigDir(projectFileUrl);
         projectConfigDir.setLastPathSegment(QStringLiteral(".kdev4"));
         auto delJob = KIO::del(projectConfigDir.toUrl());
         delJob->exec();
 
         if (!writeProjectSettingsToConfigFile(projectFileUrl, dlg)) {
             KMessageBox::error(d->m_core->uiControllerInternal()->defaultMainWindow(),
                 i18n("Unable to create configuration file %1", projectFileUrl.url()));
             return QUrl();
         }
     }
 
     return projectFileUrl;
 }
 
 bool ProjectDialogProvider::userWantsReopen()
 {
     Q_ASSERT(d);
     return (KMessageBox::questionYesNo( d->m_core->uiControllerInternal()->defaultMainWindow(),
                             i18n( "Reopen the current project?" ) )
                 == KMessageBox::No) ? false : true;
 }
 
 void ProjectController::setDialogProvider(IProjectDialogProvider* dialog)
 {
     Q_ASSERT(d->dialog);
     delete d->dialog;
     d->dialog = dialog;
 }
 
 ProjectController::ProjectController( Core* core )
         : IProjectController( core ), d( new ProjectControllerPrivate( this ) )
 {
     qRegisterMetaType<QList<QUrl>>();
 
     setObjectName(QStringLiteral("ProjectController"));
 
     d->m_core = core;
     d->model = new ProjectModel();
 
     //NOTE: this is required to be called here, such that the
     //      actions are available when the UI controller gets
     //      initialized *before* the project controller
     if (Core::self()->setupFlags() != Core::NoUi) {
         setupActions();
     }
 }
 
 void ProjectController::setupActions()
 {
     KActionCollection * ac =
         d->m_core->uiControllerInternal()->defaultMainWindow()->actionCollection();
 
     QAction*action;
 
     d->m_openProject = action = ac->addAction( QStringLiteral("project_open") );
     action->setText(i18nc( "@action", "Open / Import Project..." ) );
     action->setToolTip( i18nc( "@info:tooltip", "Open or import project" ) );
     action->setWhatsThis( i18nc( "@info:whatsthis", "Open an existing KDevelop 4 project or import "
                                                     "an existing Project into KDevelop 4. This entry "
                                                     "allows one to select a KDevelop4 project file "
                                                     "or an existing directory to open it in KDevelop. "
                                                     "When opening an existing directory that does "
                                                     "not yet have a KDevelop4 project file, the file "
                                                     "will be created." ) );
     action->setIcon(QIcon::fromTheme(QStringLiteral("project-open")));
     connect(action, &QAction::triggered, this, [&] { openProject(); });
 
     d->m_fetchProject = action = ac->addAction( QStringLiteral("project_fetch") );
     action->setText(i18nc( "@action", "Fetch Project..." ) );
     action->setIcon( QIcon::fromTheme( QStringLiteral("edit-download") ) );
     action->setToolTip( i18nc( "@info:tooltip", "Fetch project" ) );
     action->setWhatsThis( i18nc( "@info:whatsthis", "Guides the user through the project fetch "
                                                     "and then imports it into KDevelop 4." ) );
 //     action->setIcon(QIcon::fromTheme("project-open"));
     connect( action, &QAction::triggered, this, &ProjectController::fetchProject );
 
 //    action = ac->addAction( "project_close" );
 //    action->setText( i18n( "C&lose Project" ) );
 //    connect( action, SIGNAL(triggered(bool)), SLOT(closeProject()) );
 //    action->setToolTip( i18n( "Close project" ) );
 //    action->setWhatsThis( i18n( "Closes the current project." ) );
 //    action->setEnabled( false );
 
     d->m_closeProject = action = ac->addAction( QStringLiteral("project_close") );
     connect( action, &QAction::triggered, this, [&] { d->closeSelectedProjects(); } );
     action->setText( i18nc( "@action", "Close Project(s)" ) );
     action->setIcon( QIcon::fromTheme( QStringLiteral("project-development-close") ) );
     action->setToolTip( i18nc( "@info:tooltip", "Closes all currently selected projects" ) );
     action->setEnabled( false );
 
     d->m_openConfig = action = ac->addAction( QStringLiteral("project_open_config") );
     connect( action, &QAction::triggered, this, [&] { d->openProjectConfig(); } );
     action->setText( i18n( "Open Configuration..." ) );
     action->setIcon( QIcon::fromTheme(QStringLiteral("configure")) );
     action->setEnabled( false );
 
     action = ac->addAction( QStringLiteral("commit_current_project") );
     connect( action, &QAction::triggered, this, &ProjectController::commitCurrentProject );
     action->setText( i18n( "Commit Current Project..." ) );
     action->setIconText( i18n( "Commit..." ) );
     action->setIcon( QIcon::fromTheme(QStringLiteral("svn-commit")) );
     connect(d->m_core->uiControllerInternal()->defaultMainWindow(), &MainWindow::areaChanged,
             this, [&] (Sublime::Area* area) { d->areaChanged(area); });
     d->m_core->uiControllerInternal()->area(0, QStringLiteral("code"))->addAction(action);
 
     KSharedConfig * config = KSharedConfig::openConfig().data();
 //     KConfigGroup group = config->group( "General Options" );
 
-    d->m_recentAction = KStandardAction::openRecent(this, SLOT(openProject(QUrl)), this);
-    ac->addAction( QStringLiteral("project_open_recent"), d->m_recentAction );
-    d->m_recentAction->setText( i18n( "Open Recent Project" ) );
-    d->m_recentAction->setWhatsThis( i18nc( "@info:whatsthis", "Opens recently opened project." ) );
-    d->m_recentAction->loadEntries( KConfigGroup(config, "RecentProjects") );
+    d->m_recentProjectsAction = KStandardAction::openRecent(this, SLOT(openProject(QUrl)), this);
+    ac->addAction( QStringLiteral("project_open_recent"), d->m_recentProjectsAction );
+    d->m_recentProjectsAction->setText( i18n( "Open Recent Project" ) );
+    d->m_recentProjectsAction->setWhatsThis( i18nc( "@info:whatsthis", "Opens recently opened project." ) );
+    d->m_recentProjectsAction->loadEntries( KConfigGroup(config, "RecentProjects") );
 
     QAction* openProjectForFileAction = new QAction( this );
     ac->addAction(QStringLiteral("project_open_for_file"), openProjectForFileAction);
     openProjectForFileAction->setText(i18n("Open Project for Current File"));
     connect( openProjectForFileAction, &QAction::triggered, this, &ProjectController::openProjectForUrlSlot);
 }
 
 ProjectController::~ProjectController()
 {
     delete d->model;
     delete d->dialog;
 }
 
 void ProjectController::cleanup()
 {
     if ( d->m_currentlyOpening.isEmpty() ) {
         d->saveListOfOpenedProjects();
     }
 
+    saveRecentProjectsActionEntries();
+
     d->m_cleaningUp = true;
     if( buildSetModel() ) {
         buildSetModel()->storeToSession( Core::self()->activeSession() );
     }
 
     closeAllProjects();
 }
 
+void ProjectController::saveRecentProjectsActionEntries()
+{
+    auto config = KSharedConfig::openConfig();
+    KConfigGroup recentGroup = config->group("RecentProjects");
+    d->m_recentProjectsAction->saveEntries( recentGroup );
+    config->sync();
+}
+
 void ProjectController::initialize()
 {
     d->buildset = new ProjectBuildSetModel( this );
     buildSetModel()->loadFromSession( Core::self()->activeSession() );
     connect( this, &ProjectController::projectOpened,
              d->buildset, &ProjectBuildSetModel::loadFromProject );
     connect( this, &ProjectController::projectClosing,
              d->buildset, &ProjectBuildSetModel::saveToProject );
     connect( this, &ProjectController::projectClosed,
              d->buildset, &ProjectBuildSetModel::projectClosed );
 
     d->m_changesModel = new ProjectChangesModel(this);
 
     loadSettings(false);
     d->dialog = new ProjectDialogProvider(d.data());
 
     QDBusConnection::sessionBus().registerObject( QStringLiteral("/org/kdevelop/ProjectController"),
         this, QDBusConnection::ExportScriptableSlots );
 
     KSharedConfigPtr config = Core::self()->activeSession()->config();
     KConfigGroup group = config->group( "General Options" );
     const auto projects = group.readEntry( "Open Projects", QList<QUrl>() );
 
     connect( Core::self()->selectionController(), &ISelectionController::selectionChanged,
              this, [&] () { d->updateActionStates(); } );
     connect(this, &ProjectController::projectOpened,
             this, [&] () { d->updateActionStates(); });
     connect(this, &ProjectController::projectClosing,
             this, [&] () { d->updateActionStates(); });
 
     QTimer::singleShot(0, this, [this, projects](){
         openProjects(projects);
         emit initialized();
     });
 }
 
 void ProjectController::openProjects(const QList<QUrl>& projects)
 {
     foreach (const QUrl& url, projects)
         openProject(url);
 }
 
 void ProjectController::loadSettings( bool projectIsLoaded )
 {
     Q_UNUSED(projectIsLoaded)
 }
 
 void ProjectController::saveSettings( bool projectIsLoaded )
 {
     Q_UNUSED( projectIsLoaded );
 }
 
 
 int ProjectController::projectCount() const
 {
     return d->m_projects.count();
 }
 
 IProject* ProjectController::projectAt( int num ) const
 {
     if( !d->m_projects.isEmpty() && num >= 0 && num < d->m_projects.count() )
         return d->m_projects.at( num );
     return nullptr;
 }
 
 QList<IProject*> ProjectController::projects() const
 {
     return d->m_projects;
 }
 
 void ProjectController::eventuallyOpenProjectFile(KIO::Job* _job, const KIO::UDSEntryList& entries)
 {
     KIO::SimpleJob* job(dynamic_cast<KIO::SimpleJob*>(_job));
     Q_ASSERT(job);
     foreach(const KIO::UDSEntry& entry, entries) {
         if(d->m_foundProjectFile)
             break;
         if(!entry.isDir()) {
             QString name = entry.stringValue( KIO::UDSEntry::UDS_NAME );
 
             if(name.endsWith(QLatin1String(".kdev4"))) {
                 //We have found a project-file, open it
                 openProject(Path(Path(job->url()), name).toUrl());
                 d->m_foundProjectFile = true;
             }
         }
     }
 }
 
 void ProjectController::openProjectForUrlSlot(bool) {
     if(ICore::self()->documentController()->activeDocument()) {
         QUrl url = ICore::self()->documentController()->activeDocument()->url();
         IProject* project = ICore::self()->projectController()->findProjectForUrl(url);
         if(!project) {
             openProjectForUrl(url);
         }else{
             KMessageBox::error(Core::self()->uiController()->activeMainWindow(), i18n("Project already open: %1", project->name()));
         }
     }else{
         KMessageBox::error(Core::self()->uiController()->activeMainWindow(), i18n("No active document"));
     }
 }
 
 
 void ProjectController::openProjectForUrl(const QUrl& sourceUrl) {
     Q_ASSERT(!sourceUrl.isRelative());
     QUrl dirUrl = sourceUrl;
     if (sourceUrl.isLocalFile() && !QFileInfo(sourceUrl.toLocalFile()).isDir()) {
         dirUrl = dirUrl.adjusted(QUrl::RemoveFilename);
     }
     QUrl testAt = dirUrl;
 
     d->m_foundProjectFile = false;
 
     while(!testAt.path().isEmpty()) {
         KIO::ListJob* job = KIO::listDir(testAt);
 
         connect(job, &KIO::ListJob::entries, this, &ProjectController::eventuallyOpenProjectFile);
         KJobWidgets::setWindow(job, ICore::self()->uiController()->activeMainWindow());
         job->exec();
         if(d->m_foundProjectFile) {
             //Fine! We have directly opened the project
             d->m_foundProjectFile = false;
             return;
         }
         QUrl oldTest = testAt.adjusted(QUrl::RemoveFilename);
         if(oldTest == testAt)
             break;
     }
 
     QUrl askForOpen = d->dialog->askProjectConfigLocation(false, dirUrl);
 
     if(askForOpen.isValid())
         openProject(askForOpen);
 }
 
 void ProjectController::openProject( const QUrl &projectFile )
 {
     QUrl url = projectFile;
 
     if ( url.isEmpty() ) {
         url = d->dialog->askProjectConfigLocation(false);
         if ( url.isEmpty() ) {
             return;
         }
     }
 
     Q_ASSERT(!url.isRelative());
 
     QList<const Session*> existingSessions;
     if(!Core::self()->sessionController()->activeSession()->containedProjects().contains(url))
     {
         foreach( const Session* session, Core::self()->sessionController()->sessions())
         {
             if(session->containedProjects().contains(url))
             {
                 existingSessions << session;
 #if 0
                     ///@todo Think about this! Problem: The session might already contain files, the debugger might be active, etc.
                     //If this session is empty, close it
                     if(Core::self()->sessionController()->activeSession()->description().isEmpty())
                     {
                         //Terminate this instance of kdevelop if the user agrees
                         foreach(Sublime::MainWindow* window, Core::self()->uiController()->controller()->mainWindows())
                             window->close();
                     }
 #endif
             }
         }
     }
 
     if ( ! existingSessions.isEmpty() ) {
         ScopedDialog<QDialog> dialog(Core::self()->uiControllerInternal()->activeMainWindow());
         dialog->setWindowTitle(i18n("Project Already Open"));
 
         auto mainLayout = new QVBoxLayout(dialog);
         mainLayout->addWidget(new QLabel(i18n("The project you're trying to open is already open in at least one "
                                                      "other session.<br>What do you want to do?")));
         QGroupBox sessions;
         sessions.setLayout(new QVBoxLayout);
         QRadioButton* newSession = new QRadioButton(i18n("Add project to current session"));
         sessions.layout()->addWidget(newSession);
         newSession->setChecked(true);
         foreach ( const Session* session, existingSessions ) {
             QRadioButton* button = new QRadioButton(i18n("Open session %1", session->description()));
             button->setProperty("sessionid", session->id().toString());
             sessions.layout()->addWidget(button);
         }
         sessions.layout()->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding));
         mainLayout->addWidget(&sessions);
 
         auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Abort);
         auto okButton = buttonBox->button(QDialogButtonBox::Ok);
         okButton->setDefault(true);
         okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
         connect(buttonBox, &QDialogButtonBox::accepted, dialog.data(), &QDialog::accept);
         connect(buttonBox, &QDialogButtonBox::rejected, dialog.data(), &QDialog::reject);
         mainLayout->addWidget(buttonBox);
 
         if (!dialog->exec())
             return;
 
         foreach ( const QObject* obj, sessions.children() ) {
             if ( const QRadioButton* button = qobject_cast<const QRadioButton*>(obj) ) {
                 QString sessionid = button->property("sessionid").toString();
                 if ( button->isChecked() && ! sessionid.isEmpty() ) {
                     Core::self()->sessionController()->loadSession(sessionid);
                     return;
                 }
             }
         }
     }
 
     if ( url.isEmpty() )
     {
         url = d->dialog->askProjectConfigLocation(false);
     }
 
     if ( !url.isEmpty() )
     {
         d->importProject(url);
     }
 }
 
 bool ProjectController::fetchProjectFromUrl(const QUrl& repoUrl)
 {
     IPlugin* vcsOrProviderPlugin = nullptr;
 
     // TODO: query also projectprovider plugins, and that before plain vcs plugins
     // e.g. KDE provider plugin could catch URLs from mirror or pickup kde:repo things
     auto* pluginController = d->m_core->pluginController();
     const auto& vcsPlugins = pluginController->allPluginsForExtension(QStringLiteral("org.kdevelop.IBasicVersionControl"));
 
     for (auto* plugin : vcsPlugins) {
         auto* iface = plugin->extension<IBasicVersionControl>();
         if (iface->isValidRemoteRepositoryUrl(repoUrl)) {
             vcsOrProviderPlugin = plugin;
             break;
         }
     }
     if (!vcsOrProviderPlugin) {
         KMessageBox::error(Core::self()->uiController()->activeMainWindow(),
                             i18n("No enabled plugin supports this repository URL: %1", repoUrl.toDisplayString()));
         return false;
     }
 
     const QUrl url = d->dialog->askProjectConfigLocation(true, QUrl(), repoUrl, vcsOrProviderPlugin);
 
     if (!url.isEmpty()) {
         d->importProject(url);
     }
 
     return true;
 }
 
 void ProjectController::fetchProject()
 {
     QUrl url = d->dialog->askProjectConfigLocation(true);
 
     if ( !url.isEmpty() )
     {
         d->importProject(url);
     }
 }
 
 void ProjectController::projectImportingFinished( IProject* project )
 {
     if( !project )
     {
         qCWarning(SHELL) << "OOOPS: 0-pointer project";
         return;
     }
     IPlugin *managerPlugin = project->managerPlugin();
     QList<IPlugin*> pluglist;
     pluglist.append( managerPlugin );
     d->m_projectPlugins.insert( project, pluglist );
     d->m_projects.append( project );
 
     if ( d->m_currentlyOpening.isEmpty() ) {
         d->saveListOfOpenedProjects();
     }
 
     if (Core::self()->setupFlags() != Core::NoUi)
     {
-        d->m_recentAction->addUrl( project->projectFile().toUrl() );
-        KSharedConfig * config = KSharedConfig::openConfig().data();
-        KConfigGroup recentGroup = config->group("RecentProjects");
-        d->m_recentAction->saveEntries( recentGroup );
-
-        config->sync();
+        d->m_recentProjectsAction->addUrl( project->projectFile().toUrl() );
+        saveRecentProjectsActionEntries();
     }
 
     Q_ASSERT(d->m_currentlyOpening.contains(project->projectFile().toUrl()));
     d->m_currentlyOpening.removeAll(project->projectFile().toUrl());
     emit projectOpened( project );
 
     reparseProject(project);
 }
 
 // helper method for closeProject()
 void ProjectController::unloadUnusedProjectPlugins(IProject* proj)
 {
     QList<IPlugin*> pluginsForProj = d->m_projectPlugins.value( proj );
     d->m_projectPlugins.remove( proj );
 
     QList<IPlugin*> otherProjectPlugins;
     Q_FOREACH( const QList<IPlugin*>& _list, d->m_projectPlugins )
     {
         otherProjectPlugins << _list;
     }
 
     QSet<IPlugin*> pluginsForProjSet = QSet<IPlugin*>::fromList( pluginsForProj );
     QSet<IPlugin*> otherPrjPluginsSet = QSet<IPlugin*>::fromList( otherProjectPlugins );
     // loaded - target = tobe unloaded.
     QSet<IPlugin*> tobeRemoved = pluginsForProjSet.subtract( otherPrjPluginsSet );
     Q_FOREACH( IPlugin* _plugin, tobeRemoved )
     {
         KPluginMetaData _plugInfo = Core::self()->pluginController()->pluginInfo( _plugin );
         if( _plugInfo.isValid() )
         {
             QString _plugName = _plugInfo.pluginId();
             qCDebug(SHELL) << "about to unloading :" << _plugName;
             Core::self()->pluginController()->unloadPlugin( _plugName );
         }
     }
 }
 
 // helper method for closeProject()
 void ProjectController::closeAllOpenedFiles(IProject* proj)
 {
     foreach(IDocument* doc, Core::self()->documentController()->openDocuments()) {
         if (proj->inProject(IndexedString(doc->url()))) {
             doc->close();
         }
     }
 }
 
 // helper method for closeProject()
 void ProjectController::initializePluginCleanup(IProject* proj)
 {
     // Unloading (and thus deleting) these plugins is not a good idea just yet
     // as we're being called by the view part and it gets deleted when we unload the plugin(s)
     // TODO: find a better place to unload
     connect(proj, &IProject::destroyed, this, [&] { d->unloadAllProjectPlugins(); });
 }
 
 void ProjectController::takeProject(IProject* proj)
 {
     if (!proj) {
         return;
     }
 
     // loading might have failed
     d->m_currentlyOpening.removeAll(proj->projectFile().toUrl());
     d->m_projects.removeAll(proj);
     emit projectClosing(proj);
     //Core::self()->saveSettings();     // The project file is being closed.
                                         // Now we can save settings for all of the Core
                                         // objects including this one!!
     unloadUnusedProjectPlugins(proj);
     closeAllOpenedFiles(proj);
     proj->close();
     if (d->m_projects.isEmpty())
     {
         initializePluginCleanup(proj);
     }
 
     if(!d->m_cleaningUp)
         d->saveListOfOpenedProjects();
 
     emit projectClosed(proj);
 }
 
 void ProjectController::closeProject(IProject* proj)
 {
     takeProject(proj);
     proj->deleteLater(); // be safe when deleting
 }
 
 void ProjectController::closeAllProjects()
 {
     foreach (auto project, d->m_projects) {
         closeProject(project);
     }
 }
 
 void ProjectController::abortOpeningProject(IProject* proj)
 {
     d->m_currentlyOpening.removeAll(proj->projectFile().toUrl());
     emit projectOpeningAborted(proj);
 }
 
 ProjectModel* ProjectController::projectModel()
 {
     return d->model;
 }
 
 IProject* ProjectController::findProjectForUrl( const QUrl& url ) const
 {
     if (d->m_projects.isEmpty()) {
         return nullptr;
     }
 
     ProjectBaseItem* item = d->model->itemForPath(IndexedString(url));
     if (item) {
         return item->project();
     }
     return nullptr;
 }
 
 IProject* ProjectController::findProjectByName( const QString& name )
 {
     Q_FOREACH( IProject* proj, d->m_projects )
     {
         if( proj->name() == name )
         {
             return proj;
         }
     }
     return nullptr;
 }
 
 
 void ProjectController::configureProject( IProject* project )
 {
     d->projectConfig( project );
 }
 
 void ProjectController::addProject(IProject* project)
 {
     Q_ASSERT(project);
     if (d->m_projects.contains(project)) {
         qCWarning(SHELL) << "Project already tracked by this project controller:" << project;
         return;
     }
 
     // fake-emit signals so listeners are aware of a new project being added
     emit projectAboutToBeOpened(project);
     project->setParent(this);
     d->m_projects.append(project);
     emit projectOpened(project);
 }
 
 bool ProjectController::isProjectNameUsed( const QString& name ) const
 {
     foreach( IProject* p, projects() )
     {
         if( p->name() == name )
         {
             return true;
         }
     }
     return false;
 }
 
 QUrl ProjectController::projectsBaseDirectory() const
 {
     KConfigGroup group = ICore::self()->activeSession()->config()->group( "Project Manager" );
     return group.readEntry("Projects Base Directory", QUrl::fromLocalFile(QDir::homePath() + QLatin1String("/projects")));
 }
 
 QString ProjectController::prettyFilePath(const QUrl& url, FormattingOptions format) const
 {
     IProject* project = Core::self()->projectController()->findProjectForUrl(url);
 
     if(!project)
     {
         // Find a project with the correct base directory at least
         foreach(IProject* candidateProject, Core::self()->projectController()->projects())
         {
             if(candidateProject->path().toUrl().isParentOf(url))
             {
                 project = candidateProject;
                 break;
             }
         }
     }
 
     Path parent = Path(url).parent();
     QString prefixText;
     if (project) {
         if (format == FormatHtml) {
             prefixText = QLatin1String("<i>") +  project->name() + QLatin1String("</i>/");
         } else {
             prefixText = project->name() + QLatin1Char(':');
         }
         QString relativePath = project->path().relativePath(parent);
         if(relativePath.startsWith(QLatin1String("./"))) {
             relativePath = relativePath.mid(2);
         }
         if (!relativePath.isEmpty()) {
             prefixText += relativePath + QLatin1Char('/');
         }
     } else {
         prefixText = parent.pathOrUrl() + QLatin1Char('/');
     }
     return prefixText;
 }
 
 QString ProjectController::prettyFileName(const QUrl& url, FormattingOptions format) const
 {
     IProject* project = Core::self()->projectController()->findProjectForUrl(url);
     if(project && project->path() == Path(url))
     {
         if (format == FormatHtml) {
             return QLatin1String("<i>") +  project->name() + QLatin1String("</i>");
         } else {
             return project->name();
         }
     }
 
     QString prefixText = prettyFilePath( url, format );
     if (format == FormatHtml) {
         return prefixText + QLatin1String("<b>") + url.fileName() + QLatin1String("</b>");
     } else {
         return prefixText + url.fileName();
     }
 }
 
 ContextMenuExtension ProjectController::contextMenuExtension(Context* ctx, QWidget* parent)
 {
     Q_UNUSED(parent);
     ContextMenuExtension ext;
     if ( ctx->type() != Context::ProjectItemContext || !static_cast<ProjectItemContext*>(ctx)->items().isEmpty() ) {
         return ext;
     }
     ext.addAction(ContextMenuExtension::ProjectGroup, d->m_openProject);
     ext.addAction(ContextMenuExtension::ProjectGroup, d->m_fetchProject);
-    ext.addAction(ContextMenuExtension::ProjectGroup, d->m_recentAction);
+    ext.addAction(ContextMenuExtension::ProjectGroup, d->m_recentProjectsAction);
     return ext;
 }
 
 ProjectBuildSetModel* ProjectController::buildSetModel()
 {
     return d->buildset;
 }
 
 ProjectChangesModel* ProjectController::changesModel()
 {
     return d->m_changesModel;
 }
 
 void ProjectController::commitCurrentProject()
 {
     IDocument* doc=ICore::self()->documentController()->activeDocument();
     if(!doc)
         return;
 
     QUrl url=doc->url();
     IProject* project = ICore::self()->projectController()->findProjectForUrl(url);
 
     if(project && project->versionControlPlugin()) {
         IPlugin* plugin = project->versionControlPlugin();
         IBasicVersionControl* vcs=plugin->extension<IBasicVersionControl>();
 
         if(vcs) {
             ICore::self()->documentController()->saveAllDocuments(KDevelop::IDocument::Silent);
 
             const Path basePath = project->path();
             VCSCommitDiffPatchSource* patchSource = new VCSCommitDiffPatchSource(new VCSStandardDiffUpdater(vcs, basePath.toUrl()));
 
             bool ret = showVcsDiff(patchSource);
 
             if(!ret) {
                 ScopedDialog<VcsCommitDialog> commitDialog(patchSource);
                 commitDialog->setCommitCandidates(patchSource->infos());
                 commitDialog->exec();
             }
         }
     }
 }
 
 QString ProjectController::mapSourceBuild( const QString& path_, bool reverse, bool fallbackRoot ) const
 {
     Path path(path_);
     IProject* sourceDirProject = nullptr, *buildDirProject = nullptr;
     Q_FOREACH(IProject* proj, d->m_projects)
     {
         if(proj->path().isParentOf(path) || proj->path() == path)
             sourceDirProject = proj;
         if(proj->buildSystemManager())
         {
             Path buildDir = proj->buildSystemManager()->buildDirectory(proj->projectItem());
             if(buildDir.isValid() && (buildDir.isParentOf(path) || buildDir == path))
                 buildDirProject = proj;
         }
     }
 
     if(!reverse)
     {
         // Map-target is the build directory
         if(sourceDirProject && sourceDirProject->buildSystemManager())
         {
             // We're in the source, map into the build directory
             QString relativePath = sourceDirProject->path().relativePath(path);
 
             Path build = sourceDirProject->buildSystemManager()->buildDirectory(sourceDirProject->projectItem());
             build.addPath(relativePath);
             while(!QFile::exists(build.path()))
                 build = build.parent();
             return build.pathOrUrl();
         }else if(buildDirProject && fallbackRoot)
         {
             // We're in the build directory, map to the build directory root
             return buildDirProject->buildSystemManager()->buildDirectory(buildDirProject->projectItem()).pathOrUrl();
         }
     }else{
         // Map-target is the source directory
         if(buildDirProject)
         {
             Path build = buildDirProject->buildSystemManager()->buildDirectory(buildDirProject->projectItem());
             // We're in the source, map into the build directory
             QString relativePath = build.relativePath(path);
 
             Path source = buildDirProject->path();
             source.addPath(relativePath);
             while(!QFile::exists(source.path()))
                 source = source.parent();
             return source.pathOrUrl();
         }else if(sourceDirProject && fallbackRoot)
         {
             // We're in the source directory, map to the root
             return sourceDirProject->path().pathOrUrl();
         }
     }
     return QString();
 }
 
 void ProjectController::reparseProject( IProject* project, bool forceUpdate )
 {
     if (auto job = d->m_parseJobs.value(project)) {
         job->kill();
     }
 
     d->m_parseJobs[project] = new KDevelop::ParseProjectJob(project, forceUpdate);
     ICore::self()->runController()->registerJob(d->m_parseJobs[project]);
 }
 
 }
diff --git a/kdevplatform/shell/projectcontroller.h b/kdevplatform/shell/projectcontroller.h
index fcea06a05f..ca229d2138 100644
--- a/kdevplatform/shell/projectcontroller.h
+++ b/kdevplatform/shell/projectcontroller.h
@@ -1,189 +1,191 @@
 /* This file is part of KDevelop
 Copyright 2006 Adam Treat <treat@kde.org>
 Copyright 2007 Andreas Pakulat <apaku@gmx.de>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_PROJECTCONTROLLER_H
 #define KDEVPLATFORM_PROJECTCONTROLLER_H
 
 #include <interfaces/iprojectcontroller.h>
 
 #include <QUrl>
 
 #include <KIO/UDSEntry>
 
 #include "shellexport.h"
 
 namespace Sublime {
     class Area;
 }
 
 namespace KIO {
     class Job;
 }
 
 namespace KDevelop
 {
 
 class IProject;
 class Core;
 class Context;
 class ContextMenuExtension;
 class IPlugin;
 
 class KDEVPLATFORMSHELL_EXPORT IProjectDialogProvider : public QObject
 {
 Q_OBJECT
 public:
     IProjectDialogProvider();
     ~IProjectDialogProvider() override;
 
 public Q_SLOTS:
     /**
      * Displays some UI to ask the user for the project location.
      *
      * @param fetch will tell the UI that the user might want to fetch the project first
      * @param startUrl tells where to look first
      */
     virtual QUrl askProjectConfigLocation(bool fetch, const QUrl& startUrl = QUrl(),
                                           const QUrl& repoUrl = QUrl(), IPlugin* plugin = nullptr) = 0;
     virtual bool userWantsReopen() = 0;
 };
 
 class KDEVPLATFORMSHELL_EXPORT ProjectController : public IProjectController
 {
     Q_OBJECT
     Q_CLASSINFO( "D-Bus Interface", "org.kdevelop.ProjectController" )
     friend class Core;
     friend class CorePrivate;
     friend class ProjectPreferences;
 
 public:
     explicit ProjectController( Core* core );
     ~ProjectController() override;
 
     IProject* projectAt( int ) const override;
     int projectCount() const override;
     QList<IProject*> projects() const override;
 
     ProjectBuildSetModel* buildSetModel() override;
     ProjectModel* projectModel() override;
     ProjectChangesModel* changesModel() override;
     IProject* findProjectByName( const QString& name ) override;
     IProject* findProjectForUrl( const QUrl& ) const override;
 
     bool isProjectNameUsed( const QString& name ) const override;
     void setDialogProvider(IProjectDialogProvider*);
 
     QUrl projectsBaseDirectory() const override;
     QString prettyFileName(const QUrl& url, FormattingOptions format = FormatHtml) const override;
     QString prettyFilePath(const QUrl& url, FormattingOptions format = FormatHtml) const override;
 
     ContextMenuExtension contextMenuExtension(KDevelop::Context* ctx, QWidget* parent);
 
     /**
      * @param repoUrl url identifying the repo
      * @returns @c true if a plugin was found to handle the repo (also if user cancelled), @c false otherwise
      */
     bool fetchProjectFromUrl(const QUrl& repoUrl);
 
 public Q_SLOTS:
     Q_SCRIPTABLE void openProjectForUrl( const QString &sourceUrl ) { openProjectForUrl(QUrl(sourceUrl)); }
     void openProjectForUrl( const QUrl &sourceUrl ) override;
     void fetchProject();
     void openProject( const QUrl &KDev4ProjectFile = QUrl() ) override;
     void abortOpeningProject( IProject* );
     void projectImportingFinished( IProject* );
     void closeProject( IProject* ) override;
     void closeAllProjects() override;
     void configureProject( IProject* ) override;
 
     void reparseProject( IProject* project, bool forceUpdate = false  ) override;
 
     void eventuallyOpenProjectFile(KIO::Job* job, const KIO::UDSEntryList& entries);
     void openProjectForUrlSlot(bool);
 //     void changeCurrentProject( ProjectBaseItem* );
     void openProjects(const QList<QUrl>& projects);
     void commitCurrentProject();
 
     // Maps the given path from the source to the equivalent path within the build directory
     // of the corresponding project. If the path is already in the build directory and fallbackRoot is true,
     // then it is mapped to the root of the build directory.
     // This is used through DBus from within kdevplatform_shell_environment.sh
     // If reverse is true, maps the opposite direction, from build to source. [ Used in kdevplatform_shell_environment.sh ]
     Q_SCRIPTABLE QString mapSourceBuild( const QString& path, bool reverse = false, bool fallbackRoot = true ) const;
 
 protected:
     /**
      * Add the existing project @p project to the controller
      *
      * @note Method is used for testing objectives, consider using openProject() instead!
      * @note takes ownership over the project
      *
      * @sa openProject()
      */
     void addProject(IProject* proj);
     /**
      * Remove the project @p project from the controller
      *
      * @note Ownership is passed on to the caller
      */
     void takeProject(IProject* proj);
 
     virtual void loadSettings( bool projectIsLoaded );
     virtual void saveSettings( bool projectIsLoaded );
 
     virtual void initialize();
 
 Q_SIGNALS:
     void initialized();
 
 private:
     //FIXME Do not load all of this just for the project being opened...
     //void legacyLoading();
     void setupActions();
     void cleanup();
 
+    void saveRecentProjectsActionEntries();
+
     // helper methods for closeProject()
     void unloadUnusedProjectPlugins(IProject* proj);
     void disableProjectCloseAction();
     void closeAllOpenedFiles(IProject* proj);
     void initializePluginCleanup(IProject* proj);
 
 private:
     const QScopedPointer<class ProjectControllerPrivate> d;
     friend class ProjectControllerPrivate;
 };
 
 class ProjectDialogProvider : public IProjectDialogProvider
 {
 Q_OBJECT
 public:
     explicit ProjectDialogProvider(ProjectControllerPrivate* const p);
     ~ProjectDialogProvider() override;
     ProjectControllerPrivate* const d;
 
 public Q_SLOTS:
     QUrl askProjectConfigLocation(bool fetch, const QUrl& startUrl,
                                   const QUrl& repoUrl, IPlugin* plugin) override;
     bool userWantsReopen() override;
 };
 
 
 }
 #endif
diff --git a/kdevplatform/shell/textdocument.cpp b/kdevplatform/shell/textdocument.cpp
index 1952b6bec5..1aa8f1d362 100644
--- a/kdevplatform/shell/textdocument.cpp
+++ b/kdevplatform/shell/textdocument.cpp
@@ -1,753 +1,752 @@
 /***************************************************************************
  *   Copyright 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 "textdocument.h"
 
 #include <QAction>
 #include <QFile>
 #include <QMenu>
 #include <QMimeDatabase>
 #include <QPointer>
 #include <QWidget>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KTextEditor/View>
 #include <KTextEditor/Document>
 #include <KTextEditor/ModificationInterface>
 #include <KTextEditor/CodeCompletionInterface>
 #include <KTextEditor/MarkInterface>
 
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 
 #include <vcs/interfaces/icontentawareversioncontrol.h>
 
 #include <language/interfaces/editorcontext.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include "core.h"
 #include "mainwindow.h"
 #include "uicontroller.h"
 #include "partcontroller.h"
 #include "plugincontroller.h"
 #include "documentcontroller.h"
 #include "ktexteditorpluginintegration.h"
 #include "debug.h"
 
 #include <path.h>
 #include <shellutils.h>
 
 namespace KDevelop {
 
 const int MAX_DOC_SETTINGS = 20;
 
 // This sets cursor position and selection on the view to the given
 // range. Selection is set only for non-empty ranges
 // Factored into a function since its needed in 3 places already
 static void selectAndReveal( KTextEditor::View* view, const KTextEditor::Range& range ) {
     Q_ASSERT(view);
     if (range.isValid()) {
         view->setCursorPosition(range.start());
         if (!range.isEmpty()) {
             view->setSelection(range);
         }
     }
 }
 
 class TextDocumentPrivate
 {
 public:
     explicit TextDocumentPrivate(TextDocument *textDocument)
-        : document(nullptr), state(IDocument::Clean), encoding(), q(textDocument)
-        , m_loaded(false), m_addedContextMenu(nullptr)
+        : q(textDocument)
     {
     }
 
     ~TextDocumentPrivate()
     {
-        delete m_addedContextMenu;
-        m_addedContextMenu = nullptr;
+        delete addedContextMenu;
+        addedContextMenu = nullptr;
 
         saveSessionConfig();
         delete document;
     }
 
-    QPointer<KTextEditor::Document> document;
-    IDocument::DocumentState state;
-    QString encoding;
-
     void setStatus(KTextEditor::Document* document, bool dirty)
     {
         QIcon statusIcon;
 
         if (document->isModified())
             if (dirty) {
                 state = IDocument::DirtyAndModified;
                 statusIcon = QIcon::fromTheme(QStringLiteral("edit-delete"));
             } else {
                 state = IDocument::Modified;
                 statusIcon = QIcon::fromTheme(QStringLiteral("document-save"));
             }
         else
             if (dirty) {
                 state = IDocument::Dirty;
                 statusIcon = QIcon::fromTheme(QStringLiteral("document-revert"));
             } else {
                 state = IDocument::Clean;
             }
 
         q->notifyStateChanged();
         Core::self()->uiControllerInternal()->setStatusIcon(q, statusIcon);
     }
 
     inline KConfigGroup katePartSettingsGroup() const
     {
         return KSharedConfig::openConfig()->group("KatePart Settings");
     }
 
     inline QString docConfigGroupName() const
     {
         return document->url().toDisplayString(QUrl::PreferLocalFile);
     }
 
     inline KConfigGroup docConfigGroup() const
     {
         return katePartSettingsGroup().group(docConfigGroupName());
     }
 
     void saveSessionConfig()
     {
         if(document && document->url().isValid()) {
             // make sure only MAX_DOC_SETTINGS entries are stored
             KConfigGroup katePartSettings = katePartSettingsGroup();
             // ordered list of documents
             QStringList documents = katePartSettings.readEntry("documents", QStringList());
             // ensure this document is "new", i.e. at the end of the list
             documents.removeOne(docConfigGroupName());
             documents.append(docConfigGroupName());
             // remove "old" documents + their group
             while(documents.size() >= MAX_DOC_SETTINGS) {
                 katePartSettings.group(documents.takeFirst()).deleteGroup();
             }
             // update order
             katePartSettings.writeEntry("documents", documents);
 
             // actually save session config
             KConfigGroup group = docConfigGroup();
             document->writeSessionConfig(group);
         }
     }
 
     void loadSessionConfig()
     {
         if (!document || !katePartSettingsGroup().hasGroup(docConfigGroupName())) {
             return;
         }
 
         document->readSessionConfig(docConfigGroup(), {QStringLiteral("SkipUrl")});
     }
 
     // Determines whether the current contents of this document in the editor
     // could be retrieved from the VCS if they were dismissed.
     void queryCanRecreateFromVcs(KTextEditor::Document* document) const {
         IProject* project = nullptr;
         // Find projects by checking which one contains the file's parent directory,
         // to avoid issues with the cmake manager temporarily removing files from a project
         // during reloading.
         KDevelop::Path path(document->url());
         foreach ( KDevelop::IProject* current, Core::self()->projectController()->projects() ) {
             if ( current->path().isParentOf(path) ) {
                 project = current;
                 break;
             }
         }
         if (!project) {
             return;
         }
         IContentAwareVersionControl* iface;
         iface = qobject_cast< KDevelop::IContentAwareVersionControl* >(project->versionControlPlugin());
         if (!iface) {
             return;
         }
         if ( !qobject_cast<KTextEditor::ModificationInterface*>( document ) ) {
             return;
         }
 
         CheckInRepositoryJob* req = iface->isInRepository( document );
         if ( !req ) {
             return;
         }
         QObject::connect(req, &CheckInRepositoryJob::finished,
                             q, &TextDocument::repositoryCheckFinished);
         // Abort the request when the user edits the document
         QObject::connect(q->textDocument(), &KTextEditor::Document::textChanged,
                             req, &CheckInRepositoryJob::abort);
     }
 
     void modifiedOnDisk(KTextEditor::Document *document, bool /*isModified*/,
         KTextEditor::ModificationInterface::ModifiedOnDiskReason reason)
     {
         bool dirty = false;
         switch (reason)
         {
             case KTextEditor::ModificationInterface::OnDiskUnmodified:
                 break;
             case KTextEditor::ModificationInterface::OnDiskModified:
             case KTextEditor::ModificationInterface::OnDiskCreated:
             case KTextEditor::ModificationInterface::OnDiskDeleted:
                 dirty = true;
                 break;
         }
 
         // In some cases, the VCS (e.g. git) can know whether the old contents are "valuable", i.e.
         // not retrieveable from the VCS. If that is not the case, then the document can safely be
         // reloaded without displaying a dialog asking the user.
         if ( dirty ) {
             queryCanRecreateFromVcs(document);
         }
         setStatus(document, dirty);
     }
 
     TextDocument * const q;
-    bool m_loaded;
+
+    QPointer<KTextEditor::Document> document;
+    IDocument::DocumentState state = IDocument::Clean;
+    QString encoding;
+    bool loaded = false;
     // we want to remove the added stuff when the menu hides
-    QMenu* m_addedContextMenu;
+    QMenu* addedContextMenu = nullptr;
 };
 
 class TextViewPrivate
 {
 public:
     explicit TextViewPrivate(TextView* q) : q(q) {}
 
     TextView* const q;
     QPointer<KTextEditor::View> view;
     KTextEditor::Range initialRange;
 };
 
 TextDocument::TextDocument(const QUrl &url, ICore* core, const QString& encoding)
     :PartDocument(url, core), d(new TextDocumentPrivate(this))
 {
     d->encoding = encoding;
 }
 
 TextDocument::~TextDocument() = default;
 
 bool TextDocument::isTextDocument() const
 {
     if( !d->document )
     {
         /// @todo Somehow it can happen that d->document is zero, which makes
         /// code relying on "isTextDocument() == (bool)textDocument()" crash
         qCWarning(SHELL) << "Broken text-document: " << url();
         return false;
     }
 
     return true;
 }
 
 KTextEditor::Document *TextDocument::textDocument() const
 {
     return d->document;
 }
 
 QWidget *TextDocument::createViewWidget(QWidget *parent)
 {
     KTextEditor::View* view = nullptr;
 
     if (!d->document)
     {
         d->document = Core::self()->partControllerInternal()->createTextPart();
 
         // Connect to the first text changed signal, it occurs before the completed() signal
         connect(d->document.data(), &KTextEditor::Document::textChanged, this, &TextDocument::slotDocumentLoaded);
         // Also connect to the completed signal, sometimes the first text changed signal is missed because the part loads too quickly (? TODO - confirm this is necessary)
         connect(d->document.data(), static_cast<void(KTextEditor::Document::*)()>(&KTextEditor::Document::completed), this, &TextDocument::slotDocumentLoaded);
 
         // force a reparse when a document gets reloaded
         connect(d->document.data(), &KTextEditor::Document::reloaded,
                 this, [] (KTextEditor::Document* document) {
             ICore::self()->languageController()->backgroundParser()->addDocument(IndexedString(document->url()),
                     (TopDUContext::Features) ( TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdate ),
                     BackgroundParser::BestPriority, nullptr);
         });
 
         // Set encoding passed via constructor
         // Needs to be done before openUrl, else katepart won't use the encoding
         // @see KTextEditor::Document::setEncoding
         if (!d->encoding.isEmpty())
             d->document->setEncoding(d->encoding);
 
         if (!url().isEmpty() && !DocumentController::isEmptyDocumentUrl(url()))
             d->document->openUrl( url() );
 
         d->setStatus(d->document, false);
 
         /* It appears, that by default a part will be deleted the
            first view containing it is deleted.  Since we do want
            to have several views, disable that behaviour.  */
         d->document->setAutoDeletePart(false);
 
         Core::self()->partController()->addPart(d->document, false);
 
         d->loadSessionConfig();
 
         connect(d->document.data(), &KTextEditor::Document::modifiedChanged,
                  this, &TextDocument::newDocumentStatus);
         connect(d->document.data(), &KTextEditor::Document::textChanged,
                  this, &TextDocument::textChanged);
         connect(d->document.data(), &KTextEditor::Document::documentUrlChanged,
                  this, &TextDocument::documentUrlChanged);
         connect(d->document.data(), &KTextEditor::Document::documentSavedOrUploaded,
                  this, &TextDocument::documentSaved );
 
         if (qobject_cast<KTextEditor::MarkInterface*>(d->document)) {
             // can't use new signal/slot syntax here, MarkInterface is not a QObject
             connect(d->document.data(), SIGNAL(marksChanged(KTextEditor::Document*)),
                     this, SLOT(saveSessionConfig()));
         }
 
         if (auto iface = qobject_cast<KTextEditor::ModificationInterface*>(d->document)) {
             iface->setModifiedOnDiskWarning(true);
             // can't use new signal/slot syntax here, ModificationInterface is not a QObject
             connect(d->document.data(), SIGNAL(modifiedOnDisk(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)),
                 this, SLOT(modifiedOnDisk(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)));
         }
 
         notifyTextDocumentCreated();
     }
 
     view = d->document->createView(parent, Core::self()->uiControllerInternal()->defaultMainWindow()->kateWrapper()->interface());
 
     // get rid of some actions regarding the config dialog, we merge that one into the kdevelop menu already
     delete view->actionCollection()->action(QStringLiteral("set_confdlg"));
     delete view->actionCollection()->action(QStringLiteral("editor_options"));
 
     view->setStatusBarEnabled(Core::self()->partControllerInternal()->showTextEditorStatusBar());
 
     connect(view, &KTextEditor::View::contextMenuAboutToShow, this, &TextDocument::populateContextMenu);
 
     if (KTextEditor::CodeCompletionInterface* cc = dynamic_cast<KTextEditor::CodeCompletionInterface*>(view))
         cc->setAutomaticInvocationEnabled(core()->languageController()->completionSettings()->automaticCompletionEnabled());
 
     return view;
 }
 
 KParts::Part *TextDocument::partForView(QWidget *view) const
 {
     if (d->document && d->document->views().contains((KTextEditor::View*)view))
         return d->document;
     return nullptr;
 }
 
 
 
 // KDevelop::IDocument implementation
 
 void TextDocument::reload()
 {
     if (!d->document)
         return;
 
     KTextEditor::ModificationInterface* modif=nullptr;
-    if(d->state==Dirty) {
+    if(d->state ==Dirty) {
         modif = qobject_cast<KTextEditor::ModificationInterface*>(d->document);
         modif->setModifiedOnDiskWarning(false);
     }
     d->document->documentReload();
     if(modif)
         modif->setModifiedOnDiskWarning(true);
 }
 
 bool TextDocument::save(DocumentSaveMode mode)
 {
     if (!d->document)
         return true;
 
     if (mode & Discard)
         return true;
 
     switch (d->state)
     {
         case IDocument::Clean:
             return true;
 
         case IDocument::Modified:
             break;
 
         case IDocument::Dirty:
         case IDocument::DirtyAndModified:
             if (!(mode & Silent))
             {
                 int code = KMessageBox::warningYesNoCancel(
                     Core::self()->uiController()->activeMainWindow(),
                     i18n("The file \"%1\" is modified on disk.\n\nAre "
                         "you sure you want to overwrite it? (External "
                         "changes will be lost.)", d->document->url().toLocalFile()),
                     i18nc("@title:window", "Document Externally Modified"));
                 if (code != KMessageBox::Yes)
                     return false;
             }
             break;
     }
 
     if (!KDevelop::ensureWritable(QList<QUrl>() << url())) {
         return false;
     }
 
     QUrl urlBeforeSave = d->document->url();
     if (d->document->documentSave())
     {
         if (d->document->url() != urlBeforeSave)
             notifyUrlChanged();
         return true;
     }
     return false;
 }
 
 IDocument::DocumentState TextDocument::state() const
 {
     return d->state;
 }
 
 KTextEditor::Cursor KDevelop::TextDocument::cursorPosition() const
 {
     if (!d->document) {
         return KTextEditor::Cursor::invalid();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view)
         return view->cursorPosition();
 
     return KTextEditor::Cursor::invalid();
 }
 
 void TextDocument::setCursorPosition(const KTextEditor::Cursor &cursor)
 {
     if (!cursor.isValid() || !d->document)
         return;
 
     KTextEditor::View *view = activeTextView();
 
     // Rodda: Cursor must be accurate here, to the definition of accurate for KTextEditor::Cursor.
     // ie, starting from 0,0
 
     if (view)
         view->setCursorPosition(cursor);
 }
 
 KTextEditor::Range TextDocument::textSelection() const
 {
     if (!d->document) {
         return KTextEditor::Range::invalid();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view && view->selection()) {
         return view->selectionRange();
     }
 
     return PartDocument::textSelection();
 }
 
 QString TextDocument::text(const KTextEditor::Range &range) const
 {
     if (!d->document) {
         return QString();
     }
 
     return d->document->text( range );
 }
 
 QString TextDocument::textLine() const
 {
     if (!d->document) {
         return QString();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view) {
         return d->document->line( view->cursorPosition().line() );
     }
 
     return PartDocument::textLine();
 }
 
 QString TextDocument::textWord() const
 {
     if (!d->document) {
         return QString();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view) {
         KTextEditor::Cursor start = view->cursorPosition();
         qCDebug(SHELL) << "got start position from view:" << start.line() << start.column();
         QString linestr = textLine();
         int startPos = qMax( qMin( start.column(), linestr.length() - 1 ), 0 );
         int endPos = startPos;
         startPos --;
         while (startPos >= 0 &&
                (linestr[startPos].isLetterOrNumber() || linestr[startPos] == QLatin1Char('_') || linestr[startPos] == QLatin1Char('~'))) {
             --startPos;
         }
 
         while (endPos < linestr.length() &&
                (linestr[endPos].isLetterOrNumber() || linestr[endPos] == QLatin1Char('_') || linestr[endPos] == QLatin1Char('~'))) {
             ++endPos;
         }
         if( startPos != endPos )
         {
             qCDebug(SHELL) << "found word" << startPos << endPos << linestr.mid( startPos+1, endPos - startPos - 1 );
             return linestr.mid( startPos + 1, endPos - startPos - 1 );
         }
     }
 
     return PartDocument::textWord();
 }
 
 void TextDocument::setTextSelection(const KTextEditor::Range &range)
 {
     if (!range.isValid() || !d->document)
         return;
 
     KTextEditor::View *view = activeTextView();
 
     if (view) {
         selectAndReveal(view, range);
     }
 }
 
 bool TextDocument::close(DocumentSaveMode mode)
 {
     if (!PartDocument::close(mode))
         return false;
 
     if ( d->document ) {
         d->saveSessionConfig();
         delete d->document; //We have to delete the document right now, to prevent random crashes in the event handler
     }
 
     return true;
 }
 
 Sublime::View* TextDocument::newView(Sublime::Document* doc)
 {
     Q_UNUSED(doc);
     return new TextView(this);
 }
 
 }
 
 KDevelop::TextView::TextView(TextDocument * doc)
     : View(doc, View::TakeOwnership), d(new TextViewPrivate(this))
 {
 }
 
 KDevelop::TextView::~TextView() = default;
 
 QWidget * KDevelop::TextView::createWidget(QWidget * parent)
 {
     auto textDocument = qobject_cast<TextDocument*>(document());
     Q_ASSERT(textDocument);
     QWidget* widget = textDocument->createViewWidget(parent);
     d->view = qobject_cast<KTextEditor::View*>(widget);
     Q_ASSERT(d->view);
     connect(d->view.data(), &KTextEditor::View::cursorPositionChanged, this, &KDevelop::TextView::sendStatusChanged);
     return widget;
 }
 
 void KDevelop::TextView::setInitialRange(const KTextEditor::Range& range)
 {
     if (d->view) {
         selectAndReveal(d->view, range);
     } else {
         d->initialRange = range;
     }
 }
 
 KTextEditor::Range KDevelop::TextView::initialRange() const
 {
     return d->initialRange;
 }
 
 void KDevelop::TextView::readSessionConfig(KConfigGroup& config)
 {
     if (!d->view) {
         return;
     }
     d->view->readSessionConfig(config);
 }
 
 void KDevelop::TextView::writeSessionConfig(KConfigGroup& config)
 {
     if (!d->view) {
         return;
     }
     d->view->writeSessionConfig(config);
 }
 
 QString KDevelop::TextDocument::documentType() const
 {
     return QStringLiteral("Text");
 }
 
 QIcon KDevelop::TextDocument::defaultIcon() const
 {
     if (d->document) {
         QMimeType mime = QMimeDatabase().mimeTypeForName(d->document->mimeType());
         QIcon icon = QIcon::fromTheme(mime.iconName());
         if (!icon.isNull()) {
             return icon;
         }
     }
     return PartDocument::defaultIcon();
 }
 
 KTextEditor::View *KDevelop::TextView::textView() const
 {
     return d->view;
 }
 
 QString KDevelop::TextView::viewStatus() const
 {
     // only show status when KTextEditor's own status bar isn't already enabled
     const bool showStatus = !Core::self()->partControllerInternal()->showTextEditorStatusBar();
     if (!showStatus) {
         return QString();
     }
 
     const KTextEditor::Cursor pos = d->view ? d->view->cursorPosition() : KTextEditor::Cursor::invalid();
     return i18n(" Line: %1 Col: %2 ", pos.line() + 1, pos.column() + 1);
 }
 
 void KDevelop::TextView::sendStatusChanged()
 {
     emit statusChanged(this);
 }
 
 KTextEditor::View* KDevelop::TextDocument::activeTextView() const
 {
     KTextEditor::View* fallback = nullptr;
     for (auto view : views()) {
         auto textView = qobject_cast<TextView*>(view)->textView();
         if (!textView) {
             continue;
         }
         if (textView->hasFocus()) {
             return textView;
         } else if (textView->isVisible()) {
             fallback = textView;
         } else if (!fallback) {
             fallback = textView;
         }
     }
     return fallback;
 }
 
 void KDevelop::TextDocument::newDocumentStatus(KTextEditor::Document *document)
 {
     bool dirty = (d->state == IDocument::Dirty || d->state == IDocument::DirtyAndModified);
 
     d->setStatus(document, dirty);
 }
 
 void KDevelop::TextDocument::textChanged(KTextEditor::Document *document)
 {
     Q_UNUSED(document);
     notifyContentChanged();
 }
 
 void KDevelop::TextDocument::populateContextMenu( KTextEditor::View* v, QMenu* menu )
 {
-    if (d->m_addedContextMenu) {
-        foreach ( QAction* action, d->m_addedContextMenu->actions() ) {
+    if (d->addedContextMenu) {
+        foreach ( QAction* action, d->addedContextMenu->actions() ) {
             menu->removeAction(action);
         }
-        delete d->m_addedContextMenu;
+        delete d->addedContextMenu;
     }
 
-    d->m_addedContextMenu = new QMenu();
+    d->addedContextMenu = new QMenu();
 
     EditorContext c(v, v->cursorPosition());
-    auto extensions = Core::self()->pluginController()->queryPluginsForContextMenuExtensions(&c, d->m_addedContextMenu);
+    auto extensions = Core::self()->pluginController()->queryPluginsForContextMenuExtensions(&c, d->addedContextMenu);
 
-    ContextMenuExtension::populateMenu(d->m_addedContextMenu, extensions);
+    ContextMenuExtension::populateMenu(d->addedContextMenu, extensions);
 
-    foreach ( QAction* action, d->m_addedContextMenu->actions() ) {
+    foreach ( QAction* action, d->addedContextMenu->actions() ) {
         menu->addAction(action);
     }
 }
 
 void KDevelop::TextDocument::repositoryCheckFinished(bool canRecreate) {
     if ( d->state != IDocument::Dirty && d->state != IDocument::DirtyAndModified ) {
         // document is not dirty for whatever reason, nothing to do.
         return;
     }
     if ( ! canRecreate ) {
         return;
     }
     KTextEditor::ModificationInterface* modIface = qobject_cast<KTextEditor::ModificationInterface*>( d->document );
     Q_ASSERT(modIface);
     // Ok, all safe, we can clean up the document. Close it if the file is gone,
     // and reload if it's still there.
     d->setStatus(d->document, false);
     modIface->setModifiedOnDisk(KTextEditor::ModificationInterface::OnDiskUnmodified);
     if ( QFile::exists(d->document->url().path()) ) {
         reload();
     } else {
         close(KDevelop::IDocument::Discard);
     }
 }
 
 void KDevelop::TextDocument::slotDocumentLoaded()
 {
-    if (d->m_loaded)
+    if (d->loaded)
         return;
     // Tell the editor integrator first
-    d->m_loaded = true;
+    d->loaded = true;
     notifyLoaded();
 }
 
 void KDevelop::TextDocument::documentSaved(KTextEditor::Document* document, bool saveAs)
 {
     Q_UNUSED(document);
     Q_UNUSED(saveAs);
     notifySaved();
     notifyStateChanged();
 }
 
 void KDevelop::TextDocument::documentUrlChanged(KTextEditor::Document* document)
 {
     Q_UNUSED(document);
     if (url() != d->document->url())
         setUrl(d->document->url());
 }
 
 #include "moc_textdocument.cpp"
diff --git a/kdevplatform/shell/workingsetcontroller.cpp b/kdevplatform/shell/workingsetcontroller.cpp
index 5ed2b143e5..f2782a4d9e 100644
--- a/kdevplatform/shell/workingsetcontroller.cpp
+++ b/kdevplatform/shell/workingsetcontroller.cpp
@@ -1,341 +1,319 @@
 /*
     Copyright 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 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 "workingsetcontroller.h"
 
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include "mainwindow.h"
 #include "partdocument.h"
 #include "uicontroller.h"
 
 #include <interfaces/iuicontroller.h>
 #include <interfaces/isession.h>
 
 #include <sublime/view.h>
 #include <sublime/area.h>
 
 #include <util/activetooltip.h>
 
 #include "workingsets/workingset.h"
 #include "workingsets/workingsettooltipwidget.h"
 #include "workingsets/workingsetwidget.h"
 #include "workingsets/closedworkingsetswidget.h"
 #include "core.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 const int toolTipTimeout = 2000;
 
 WorkingSetController::WorkingSetController()
     : m_emptyWorkingSet(nullptr), m_changingWorkingSet(false)
 {
     m_hideToolTipTimer = new QTimer(this);
     m_hideToolTipTimer->setInterval(toolTipTimeout);
     m_hideToolTipTimer->setSingleShot(true);
 }
 
 void WorkingSetController::initialize()
 {
     //Load all working-sets
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     foreach(const QString& set, setConfig.groupList()) {
         // do not load working set if the id contains an '|', because it then belongs to an area.
         // this is functionally equivalent to the if ( ! config->icon ) stuff which was there before.
         if (set.contains(QLatin1Char('|'))) {
             continue;
         }
         getWorkingSet(set);
     }
 
     m_emptyWorkingSet = new WorkingSet(QStringLiteral("empty"));
 
     if(!(Core::self()->setupFlags() & Core::NoUi)) {
         setupActions();
     }
 }
 
 void WorkingSetController::cleanup()
 {
     foreach(Sublime::MainWindow* window, Core::self()->uiControllerInternal()->mainWindows()) {
         foreach (Sublime::Area *area, window->areas()) {
             if (!area->workingSet().isEmpty()) {
                 Q_ASSERT(m_workingSets.contains(area->workingSet()));
                 m_workingSets[area->workingSet()]->saveFromArea(area, area->rootIndex());
             }
         }
     }
 
     foreach(WorkingSet* set, m_workingSets) {
         qCDebug(SHELL) << "set" << set->id() << "persistent" << set->isPersistent() << "has areas:" << set->hasConnectedAreas() << "files" << set->fileList();
         if(!set->isPersistent() && !set->hasConnectedAreas()) {
             qCDebug(SHELL) << "deleting";
             set->deleteSet(true, true);
         }
         delete set;
     }
 
     m_workingSets.clear();
 
     delete m_emptyWorkingSet;
     m_emptyWorkingSet = nullptr;
 }
 
 const QString WorkingSetController::makeSetId(const QString& prefix) const
 {
     QString newId;
     const uint maxRetries = 10;
     for(uint retry = 2; retry <= maxRetries; retry++) {
         newId = QStringLiteral("%1_%2").arg(prefix).arg(qrand() % 10000000);
         WorkingSetIconParameters params(newId);
         foreach(WorkingSet* set, m_workingSets) {
             if(set->isEmpty()) {
                 continue;
             }
             // The last retry will always generate a valid set
             if(retry != maxRetries && WorkingSetIconParameters(set->id()).similarity(params) >= retry*8) {
                 newId = QString();
                 break;
             }
         }
         if(! newId.isEmpty()) {
             break;
         }
     }
     return newId;
 }
 
 WorkingSet* WorkingSetController::newWorkingSet(const QString& prefix)
 {
     return getWorkingSet(makeSetId(prefix));
 }
 
 WorkingSet* WorkingSetController::getWorkingSet(const QString& id)
 {
     if(id.isEmpty())
         return m_emptyWorkingSet;
 
     if(!m_workingSets.contains(id)) {
         WorkingSet* set = new WorkingSet(id);
         connect(set, &WorkingSet::aboutToRemove,
                 this, &WorkingSetController::aboutToRemoveWorkingSet);
         m_workingSets[id] = set;
         emit workingSetAdded(set);
     }
 
     return m_workingSets[id];
 }
 
 QWidget* WorkingSetController::createSetManagerWidget(MainWindow* parent, Sublime::Area* fixedArea) {
     if (fixedArea) {
         return new WorkingSetWidget(fixedArea, parent);
     } else {
         return new ClosedWorkingSetsWidget(parent);
     }
 }
 
 void WorkingSetController::setupActions()
 {
-/*
-    KActionCollection * ac =
-        Core::self()->uiControllerInternal()->defaultMainWindow()->actionCollection();
-
-    QAction* action;
-
-    action = ac->addAction ( "view_next_window" );
-    action->setText( i18n( "Next Document" ) );
-    action->setIcon( QIcon::fromTheme("go-next") );
-    action->setShortcut( Qt::ALT + Qt::SHIFT + Qt::Key_Right );
-    action->setWhatsThis( i18n( "Switch the focus to the next open document." ) );
-    action->setStatusTip( i18n( "Switch the focus to the next open document." ) );
-    connect( action, SIGNAL(triggered()), this, SLOT(nextDocument()) );
-
-    action = ac->addAction ( "view_previous_window" );
-    action->setText( i18n( "Previous Document" ) );
-    action->setIcon( QIcon::fromTheme("go-previous") );
-    action->setShortcut( Qt::ALT + Qt::SHIFT + Qt::Key_Left );
-    action->setWhatsThis( i18n( "Switch the focus to the previous open document." ) );
-    action->setStatusTip( i18n( "Switch the focus to the previous open document." ) );
-    connect( action, SIGNAL(triggered()), this, SLOT(previousDocument()) );
-*/
 }
 
 ActiveToolTip* WorkingSetController::tooltip() const
 {
     return m_tooltip;
 }
 
 void WorkingSetController::showToolTip(WorkingSet* set, const QPoint& pos)
 {
     delete m_tooltip;
 
     KDevelop::MainWindow* window = static_cast<KDevelop::MainWindow*>(Core::self()->uiControllerInternal()->activeMainWindow());
 
     m_tooltip = new KDevelop::ActiveToolTip(window, pos);
     QVBoxLayout* layout = new QVBoxLayout(m_tooltip);
     layout->setMargin(0);
     WorkingSetToolTipWidget* widget = new WorkingSetToolTipWidget(m_tooltip, set, window);
     layout->addWidget(widget);
     m_tooltip->resize( m_tooltip->sizeHint() );
 
     connect(widget, &WorkingSetToolTipWidget::shouldClose, m_tooltip.data(), &ActiveToolTip::close);
 
     ActiveToolTip::showToolTip(m_tooltip);
 }
 
 void WorkingSetController::showGlobalToolTip()
 {
     KDevelop::MainWindow* window = static_cast<KDevelop::MainWindow*>(Core::self()->uiControllerInternal()->activeMainWindow());
 
     showToolTip(getWorkingSet(window->area()->workingSet()),
                               window->mapToGlobal(window->geometry().topRight()));
 
     connect(m_hideToolTipTimer, &QTimer::timeout,  m_tooltip.data(), &ActiveToolTip::deleteLater);
     m_hideToolTipTimer->start();
     connect(m_tooltip.data(), &ActiveToolTip::mouseIn, m_hideToolTipTimer, &QTimer::stop);
     connect(m_tooltip.data(), &ActiveToolTip::mouseOut, m_hideToolTipTimer, static_cast<void(QTimer::*)()>(&QTimer::start));
 }
 
 WorkingSetToolTipWidget* WorkingSetController::workingSetToolTip()
 {
     if(!m_tooltip)
         showGlobalToolTip();
 
     m_hideToolTipTimer->stop();
     m_hideToolTipTimer->start(toolTipTimeout);
 
     if(m_tooltip)
     {
         WorkingSetToolTipWidget* widget = m_tooltip->findChild<WorkingSetToolTipWidget*>();
         Q_ASSERT(widget);
         return widget;
     }
     return nullptr;
 }
 
 void WorkingSetController::nextDocument()
 {
     auto widget = workingSetToolTip();
     if (widget) {
         widget->nextDocument();
     }
 }
 
 void WorkingSetController::previousDocument()
 {
     auto widget = workingSetToolTip();
     if (widget) {
         widget->previousDocument();
     }
 }
 
 void WorkingSetController::initializeController( UiController* controller )
 {
   connect( controller, &UiController::areaCreated, this, &WorkingSetController::areaCreated );
 }
 
 QList< WorkingSet* > WorkingSetController::allWorkingSets() const
 {
   return m_workingSets.values();
 }
 
 void WorkingSetController::areaCreated( Sublime::Area* area )
 {
     if (!area->workingSet().isEmpty()) {
         WorkingSet* set = getWorkingSet( area->workingSet() );
         set->connectArea( area );
     }
 
     connect(area, &Sublime::Area::changingWorkingSet,
             this, &WorkingSetController::changingWorkingSet);
     connect(area, &Sublime::Area::changedWorkingSet,
             this, &WorkingSetController::changedWorkingSet);
     connect(area, &Sublime::Area::viewAdded,
             this, &WorkingSetController::viewAdded);
     connect(area, &Sublime::Area::clearWorkingSet,
             this, &WorkingSetController::clearWorkingSet);
 }
 
 void WorkingSetController::changingWorkingSet(Sublime::Area* area, const QString& from, const QString& to)
 {
     qCDebug(SHELL) << "changing working-set from" << from << "to" << to << "area" << area;
     if (from == to)
         return;
 
     if (!from.isEmpty()) {
         WorkingSet* oldSet = getWorkingSet(from);
         oldSet->disconnectArea(area);
         if (!oldSet->id().isEmpty()) {
             oldSet->saveFromArea(area, area->rootIndex());
         }
     }
 }
 
 void WorkingSetController::changedWorkingSet(Sublime::Area* area, const QString& from, const QString& to)
 {
     qCDebug(SHELL) << "changed working-set from" << from << "to" << to << "area" << area;
     if (from == to || m_changingWorkingSet)
         return;
 
     if (!to.isEmpty()) {
         WorkingSet* newSet = getWorkingSet(to);
         newSet->connectArea(area);
         newSet->loadToArea(area, area->rootIndex());
     }else{
         // Clear silently, any user-interaction should have happened before
         area->clearViews(true);
     }
 
     emit workingSetSwitched();
 }
 
 void WorkingSetController::viewAdded( Sublime::AreaIndex* , Sublime::View* )
 {
     Sublime::Area* area = qobject_cast< Sublime::Area* >(sender());
     Q_ASSERT(area);
 
     if (area->workingSet().isEmpty()) {
         //Spawn a new working-set
         m_changingWorkingSet = true;
         WorkingSet* set = Core::self()->workingSetControllerInternal()->newWorkingSet(area->objectName());
         qCDebug(SHELL) << "Spawned new working-set" << set->id() << "because a view was added";
         set->connectArea(area);
         set->saveFromArea(area, area->rootIndex());
         area->setWorkingSet(set->id());
         m_changingWorkingSet = false;
     }
 }
 
 void WorkingSetController::clearWorkingSet(Sublime::Area * area)
 {
     const QString workingSet = area->workingSet();
     if (workingSet.isEmpty()) {
         // Nothing to do - area has no working set
         return;
     }
 
     WorkingSet* set = getWorkingSet(workingSet);
     set->deleteSet(true);
 
     WorkingSet* newSet = getWorkingSet(workingSet);
     newSet->connectArea(area);
     newSet->loadToArea(area, area->rootIndex());
     Q_ASSERT(newSet->fileList().isEmpty());
 }
diff --git a/plugins/gdb/gdboutputwidget.cpp b/plugins/gdb/gdboutputwidget.cpp
index f78e534121..22519fe8cf 100644
--- a/plugins/gdb/gdboutputwidget.cpp
+++ b/plugins/gdb/gdboutputwidget.cpp
@@ -1,458 +1,459 @@
 /*
  * GDB Debugger Support
  *
  * Copyright 2003 John Birch <jbb@kdevelop.org>
  * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "gdboutputwidget.h"
 
 #include "dbgglobal.h"
 #include "debuggerplugin.h"
 #include "debuglog.h"
 #include "debugsession.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 
 #include <KColorScheme>
 #include <KHistoryComboBox>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QClipboard>
 #include <QFocusEvent>
 #include <QMenu>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QToolButton>
 #include <QToolTip>
 #include <QScrollBar>
 #include <QScopedPointer>
 
 using namespace KDevMI::GDB;
 
 /***************************************************************************/
 
 GDBOutputWidget::GDBOutputWidget(CppDebuggerPlugin* plugin, QWidget *parent) :
     QWidget(parent),
     m_userGDBCmdEditor(nullptr),
     m_Interrupt(nullptr),
     m_gdbView(nullptr),
-    showInternalCommands_(false),
-    maxLines_(5000)
+    m_showInternalCommands(false),
+    m_maxLines(5000)
 {
     setWindowIcon(QIcon::fromTheme(QStringLiteral("dialog-scripts"), windowIcon()));
     setWindowTitle(i18n("GDB Output"));
     setWhatsThis(i18n("<b>GDB output</b><p>"
                     "Shows all gdb commands being executed. "
                     "You can also issue any other gdb command while debugging.</p>"));
 
     m_gdbView = new OutputTextEdit(this);
+    m_gdbView->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
     m_gdbView->setReadOnly(true);
 
     m_userGDBCmdEditor = new KHistoryComboBox (this);
 
     QLabel *label = new QLabel(i18n("&GDB cmd:"), this);
     label->setBuddy(m_userGDBCmdEditor);
 
     m_Interrupt = new QToolButton( this );
     m_Interrupt->setIcon ( QIcon::fromTheme( QStringLiteral("media-playback-pause") ) );
     m_Interrupt->setToolTip( i18n ( "Pause execution of the app to enter gdb commands" ) );
 
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     topLayout->addWidget(m_gdbView);
     topLayout->setStretchFactor(m_gdbView, 1);
     topLayout->setMargin(0);
 
     QBoxLayout *userGDBCmdEntry = new QHBoxLayout();
     userGDBCmdEntry->addWidget(label);
     userGDBCmdEntry->addWidget(m_userGDBCmdEditor);
     userGDBCmdEntry->setStretchFactor(m_userGDBCmdEditor, 1);
     userGDBCmdEntry->addWidget(m_Interrupt);
     topLayout->addLayout(userGDBCmdEntry);
 
     setLayout(topLayout);
 
     slotStateChanged(s_none, s_dbgNotStarted);
 
     connect(m_userGDBCmdEditor, static_cast<void(KHistoryComboBox::*)()>(&KHistoryComboBox::returnPressed),
             this, &GDBOutputWidget::slotGDBCmd);
     connect(m_Interrupt, &QToolButton::clicked, this, &GDBOutputWidget::breakInto);
 
-    updateTimer_.setSingleShot(true);
-    connect(&updateTimer_, &QTimer::timeout,
+    m_updateTimer.setSingleShot(true);
+    connect(&m_updateTimer, &QTimer::timeout,
              this, &GDBOutputWidget::flushPending);
 
     connect(KDevelop::ICore::self()->debugController(), &KDevelop::IDebugController::currentSessionChanged,
             this, &GDBOutputWidget::currentSessionChanged);
 
     connect(plugin, &CppDebuggerPlugin::reset, this, &GDBOutputWidget::clear);
     connect(plugin, &CppDebuggerPlugin::raiseDebuggerConsoleViews, this, &GDBOutputWidget::requestRaise);
 
     currentSessionChanged(KDevelop::ICore::self()->debugController()->currentSession());
 
 //     TODO Port to KF5
 //     connect(KGlobalSettings::self(), SIGNAL(kdisplayPaletteChanged()),
 //             this, SLOT(updateColors()));
     updateColors();
 
 }
 
 void GDBOutputWidget::updateColors()
 {
     KColorScheme scheme(QPalette::Active);
-    gdbColor_ = scheme.foreground(KColorScheme::LinkText).color();
-    errorColor_ = scheme.foreground(KColorScheme::NegativeText).color();
+    m_gdbColor = scheme.foreground(KColorScheme::LinkText).color();
+    m_errorColor = scheme.foreground(KColorScheme::NegativeText).color();
 }
 
 void GDBOutputWidget::currentSessionChanged(KDevelop::IDebugSession* s)
 {
     if (!s)
         return;
 
     DebugSession *session = qobject_cast<DebugSession*>(s);
     if (!session)
         return;
 
      connect(this, &GDBOutputWidget::userGDBCmd,
              session, &DebugSession::addUserCommand);
      connect(this, &GDBOutputWidget::breakInto,
              session, &DebugSession::interruptDebugger);
 
      connect(session, &DebugSession::debuggerInternalCommandOutput,
              this, &GDBOutputWidget::slotInternalCommandStdout);
      connect(session, &DebugSession::debuggerUserCommandOutput,
              this, &GDBOutputWidget::slotUserCommandStdout);
      // debugger internal output, treat it as an internal command output
      connect(session, &DebugSession::debuggerInternalOutput,
              this, &GDBOutputWidget::slotInternalCommandStdout);
 
      connect(session, &DebugSession::debuggerStateChanged,
              this, &GDBOutputWidget::slotStateChanged);
 
      slotStateChanged(s_none, session->debuggerState());
 }
 
 
 /***************************************************************************/
 
 GDBOutputWidget::~GDBOutputWidget()
 {
     delete m_gdbView;
     delete m_userGDBCmdEditor;
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::clear()
 {
     if (m_gdbView)
         m_gdbView->clear();
 
-    userCommands_.clear();
-    allCommands_.clear();
+    m_userCommands_.clear();
+    m_allCommands.clear();
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotInternalCommandStdout(const QString& line)
 {
     newStdoutLine(line, true);
 }
 
 void GDBOutputWidget::slotUserCommandStdout(const QString& line)
 {
     qCDebug(DEBUGGERGDB) << "User command stdout: " << line;
     newStdoutLine(line, false);
 }
 
 namespace {
     QString colorify(QString text, const QColor& color)
     {
         // Make sure the newline is at the end of the newly-added
         // string. This is so that we can always correctly remove
         // newline inside 'flushPending'.
         if (!text.endsWith('\n'))
           text.append('\n');
 
         if (text.endsWith('\n'))
         {
             text.remove(text.length()-1, 1);
         }
         text = "<font color=\"" + color.name() +  "\">" + text + "</font><br>";
         return text;
     }
 }
 
 
 void GDBOutputWidget::newStdoutLine(const QString& line,
                                     bool internal)
 {
     QString s = line.toHtmlEscaped();
     if (s.startsWith(QLatin1String("(gdb)")))
     {
-        s = colorify(s, gdbColor_);
+        s = colorify(s, m_gdbColor);
     }
     else
         s.replace('\n', QLatin1String("<br>"));
 
-    allCommands_.append(s);
-    allCommandsRaw_.append(line);
-    trimList(allCommands_, maxLines_);
-    trimList(allCommandsRaw_, maxLines_);
+    m_allCommands.append(s);
+    m_allCommandsRaw.append(line);
+    trimList(m_allCommands, m_maxLines);
+    trimList(m_allCommandsRaw, m_maxLines);
 
     if (!internal)
     {
-        userCommands_.append(s);
-        userCommandsRaw_.append(line);
-        trimList(userCommands_, maxLines_);
-        trimList(userCommandsRaw_, maxLines_);
+        m_userCommands_.append(s);
+        m_userCommandsRaw.append(line);
+        trimList(m_userCommands_, m_maxLines);
+        trimList(m_userCommandsRaw, m_maxLines);
     }
 
-    if (!internal || showInternalCommands_)
+    if (!internal || m_showInternalCommands)
         showLine(s);
 }
 
 
 void GDBOutputWidget::showLine(const QString& line)
 {
-    pendingOutput_ += line;
+    m_pendingOutput += line;
 
     // To improve performance, we update the view after some delay.
-    if (!updateTimer_.isActive())
+    if (!m_updateTimer.isActive())
     {
-        updateTimer_.start(100);
+        m_updateTimer.start(100);
     }
 }
 
 void GDBOutputWidget::trimList(QStringList& l, int max_size)
 {
     int length = l.count();
     if (length > max_size)
     {
         for(int to_delete = length - max_size; to_delete; --to_delete)
         {
             l.erase(l.begin());
         }
     }
 }
 
 void GDBOutputWidget::setShowInternalCommands(bool show)
 {
-    if (show != showInternalCommands_)
+    if (show != m_showInternalCommands)
     {
-        showInternalCommands_ = show;
+        m_showInternalCommands = show;
 
         // Set of strings to show changes, text edit still has old
         // set. Refresh.
         m_gdbView->clear();
         QStringList& newList =
-            showInternalCommands_ ? allCommands_ : userCommands_;
+            m_showInternalCommands ? m_allCommands : m_userCommands_;
 
         QStringList::iterator i = newList.begin(), e = newList.end();
         for(; i != e; ++i)
         {
             // Note that color formatting is already applied to '*i'.
             showLine(*i);
         }
     }
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotReceivedStderr(const char* line)
 {
-    QString colored = colorify(QString::fromLatin1(line).toHtmlEscaped(), errorColor_);
+    QString colored = colorify(QString::fromLatin1(line).toHtmlEscaped(), m_errorColor);
     // Errors are shown inside user commands too.
-    allCommands_.append(colored);
-    trimList(allCommands_, maxLines_);
-    userCommands_.append(colored);
-    trimList(userCommands_, maxLines_);
+    m_allCommands.append(colored);
+    trimList(m_allCommands, m_maxLines);
+    m_userCommands_.append(colored);
+    trimList(m_userCommands_, m_maxLines);
 
-    allCommandsRaw_.append(line);
-    trimList(allCommandsRaw_, maxLines_);
-    userCommandsRaw_.append(line);
-    trimList(userCommandsRaw_, maxLines_);
+    m_allCommandsRaw.append(line);
+    trimList(m_allCommandsRaw, m_maxLines);
+    m_userCommandsRaw.append(line);
+    trimList(m_userCommandsRaw, m_maxLines);
 
     showLine(colored);
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotGDBCmd()
 {
     QString GDBCmd(m_userGDBCmdEditor->currentText());
     if (!GDBCmd.isEmpty())
     {
         m_userGDBCmdEditor->addToHistory(GDBCmd);
         m_userGDBCmdEditor->clearEditText();
         emit userGDBCmd(GDBCmd);
     }
 }
 
 void GDBOutputWidget::flushPending()
 {
     m_gdbView->setUpdatesEnabled(false);
 
     // QTextEdit adds newline after paragraph automatically.
     // So, remove trailing newline to avoid double newlines.
-    if (pendingOutput_.endsWith('\n'))
-        pendingOutput_.remove(pendingOutput_.length()-1, 1);
-    Q_ASSERT(!pendingOutput_.endsWith('\n'));
+    if (m_pendingOutput.endsWith('\n'))
+        m_pendingOutput.remove(m_pendingOutput.length()-1, 1);
+    Q_ASSERT(!m_pendingOutput.endsWith('\n'));
 
     QTextDocument *document = m_gdbView->document();
     QTextCursor cursor(document);
     cursor.movePosition(QTextCursor::End);
-    cursor.insertHtml(pendingOutput_);
-    pendingOutput_ = QLatin1String("");
+    cursor.insertHtml(m_pendingOutput);
+    m_pendingOutput = QLatin1String("");
 
     m_gdbView->verticalScrollBar()->setValue(m_gdbView->verticalScrollBar()->maximum());
     m_gdbView->setUpdatesEnabled(true);
     m_gdbView->update();
     if (m_cmdEditorHadFocus) {
         m_userGDBCmdEditor->setFocus();
     }
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotStateChanged(KDevMI::DBGStateFlags oldStatus, KDevMI::DBGStateFlags newStatus)
 {
     Q_UNUSED(oldStatus)
     if (newStatus & s_dbgNotStarted)
     {
         m_Interrupt->setEnabled(false);
         m_userGDBCmdEditor->setEnabled(false);
         return;
     }
     else
     {
         m_Interrupt->setEnabled(true);
     }
 
     if (newStatus & s_dbgBusy)
     {
         if (m_userGDBCmdEditor->isEnabled()) {
             m_cmdEditorHadFocus = m_userGDBCmdEditor->hasFocus();
         }
         m_userGDBCmdEditor->setEnabled(false);
     }
     else
     {
         m_userGDBCmdEditor->setEnabled(true);
     }
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::focusInEvent(QFocusEvent */*e*/)
 {
     m_gdbView->verticalScrollBar()->setValue(m_gdbView->verticalScrollBar()->maximum());
     m_userGDBCmdEditor->setFocus();
 }
 
 void GDBOutputWidget::savePartialProjectSession()
 {
     KConfigGroup config(KSharedConfig::openConfig(), "GDB Debugger");
 
-    config.writeEntry("showInternalCommands", showInternalCommands_);
+    config.writeEntry("showInternalCommands", m_showInternalCommands);
 }
 
 void GDBOutputWidget::restorePartialProjectSession()
 {
     KConfigGroup config(KSharedConfig::openConfig(), "GDB Debugger");
 
-    showInternalCommands_ = config.readEntry("showInternalCommands", false);
+    m_showInternalCommands = config.readEntry("showInternalCommands", false);
 }
 
 
 void GDBOutputWidget::contextMenuEvent(QContextMenuEvent * e)
 {
     QScopedPointer<QMenu> popup(new QMenu(this));
 
     QAction* action = popup->addAction(i18n("Show Internal Commands"),
                                this,
                                SLOT(toggleShowInternalCommands()));
 
     action->setCheckable(true);
-    action->setChecked(showInternalCommands_);
+    action->setChecked(m_showInternalCommands);
     action->setWhatsThis(i18n(
             "Controls if commands issued internally by KDevelop "
             "will be shown or not.<br>"
             "This option will affect only future commands, it will not "
             "add or remove already issued commands from the view."));
 
     popup->addAction(i18n("Copy All"),
                       this,
                       SLOT(copyAll()));
 
     popup->exec(e->globalPos());
 }
 
 void GDBOutputWidget::copyAll()
 {
     /* See comments for allCommandRaw_ for explanations of
        this complex logic, as opposed to calling text(). */
-    const QStringList& raw = showInternalCommands_ ?
-        allCommandsRaw_ : userCommandsRaw_;
+    const QStringList& raw = m_showInternalCommands ?
+        m_allCommandsRaw : m_userCommandsRaw;
     QString text;
     for (int i = 0; i < raw.size(); ++i)
         text += raw.at(i);
 
     // Make sure the text is pastable both with Ctrl-C and with
     // middle click.
     QApplication::clipboard()->setText(text, QClipboard::Clipboard);
     QApplication::clipboard()->setText(text, QClipboard::Selection);
 }
 
 void GDBOutputWidget::toggleShowInternalCommands()
 {
-    setShowInternalCommands(!showInternalCommands_);
+    setShowInternalCommands(!m_showInternalCommands);
 }
 
 
 OutputTextEdit::OutputTextEdit(GDBOutputWidget * parent)
-    : QTextEdit(parent)
+    : QPlainTextEdit(parent)
 {
 }
 
 void OutputTextEdit::contextMenuEvent(QContextMenuEvent * event)
 {
     QScopedPointer<QMenu> popup(createStandardContextMenu());
 
     QAction* action = popup->addAction(i18n("Show Internal Commands"),
                                parent(),
                                SLOT(toggleShowInternalCommands()));
 
     action->setCheckable(true);
     action->setChecked(static_cast<GDBOutputWidget*>(parent())->showInternalCommands());
     action->setWhatsThis(i18n(
             "Controls if commands issued internally by KDevelop "
             "will be shown or not.<br>"
             "This option will affect only future commands, it will not "
             "add or remove already issued commands from the view."));
 
     popup->exec(event->globalPos());
 }
 
 bool GDBOutputWidget::showInternalCommands() const
 {
-    return showInternalCommands_;
+    return m_showInternalCommands;
 }
diff --git a/plugins/gdb/gdboutputwidget.h b/plugins/gdb/gdboutputwidget.h
index ee6a119cba..10250670d3 100644
--- a/plugins/gdb/gdboutputwidget.h
+++ b/plugins/gdb/gdboutputwidget.h
@@ -1,154 +1,154 @@
 /*
  * GDB Debugger Support
  *
  * Copyright 2003 John Birch <jbb@kdevelop.org>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _GDBOUTPUTWIDGET_H_
 #define _GDBOUTPUTWIDGET_H_
 
 #include "dbgglobal.h"
 
-#include <QTextEdit>
+#include <QPlainTextEdit>
 #include <QTimer>
 #include <QStringList>
 
 namespace KDevelop {
 class IDebugSession;
 }
 
 class KHistoryComboBox;
 class QToolButton;
 
 namespace KDevMI
 {
 namespace GDB
 {
 
 class GDBController;
 class CppDebuggerPlugin;
 
 class GDBOutputWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     explicit GDBOutputWidget(CppDebuggerPlugin* plugin, QWidget *parent=nullptr );
     ~GDBOutputWidget() override;
 
     void savePartialProjectSession();
     void restorePartialProjectSession();
 
     bool showInternalCommands() const;
 
 public Q_SLOTS:
     void clear();
 
     void slotInternalCommandStdout(const QString& line);
     void slotUserCommandStdout(const QString& line);
     void slotReceivedStderr(const char* line);
     void slotStateChanged(DBGStateFlags oldStatus, DBGStateFlags newStatus);
 
     void slotGDBCmd();
 
     void flushPending();
 
     void copyAll();
     void toggleShowInternalCommands();
 
 private Q_SLOTS:
     void currentSessionChanged(KDevelop::IDebugSession *session);
     void updateColors();
 
 protected:
     void focusInEvent(QFocusEvent *e) override;
     void contextMenuEvent(QContextMenuEvent* e) override;
 
 Q_SIGNALS:
     void requestRaise();
     void userGDBCmd(const QString &cmd);
     void breakInto();
 
 private:
     void newStdoutLine(const QString& line, bool internal);
 
     /** Arranges for 'line' to be shown to the user.
         Adds 'line' to pendingOutput_ and makes sure
         updateTimer_ is running. */
     void showLine(const QString& line);
 
     /** Makes 'l' no longer than 'max_size' by
         removing excessive elements from the top.
     */
     void trimList(QStringList& l, int max_size);
 
     GDBController* m_controller;
     KHistoryComboBox*  m_userGDBCmdEditor;
     QToolButton*    m_Interrupt;
-    QTextEdit*      m_gdbView;
+    QPlainTextEdit*      m_gdbView;
 
     bool m_cmdEditorHadFocus;
 
     void setShowInternalCommands(bool);
     friend class OutputText;
 
     /** The output from user commands only and from
         all commands. We keep it here so that if we switch
         "Show internal commands" on, we can show previous 
         internal commands. 
     */
-    QStringList userCommands_, allCommands_;
+    QStringList m_userCommands_, m_allCommands;
     /** Same output, without any fancy formatting.  Keeping it
         here because I can't find any way to extract raw text,
         without formatting, out of QTextEdit except for
         selecting everything and calling 'copy()'. The latter
         approach is just ugly.  */
-    QStringList userCommandsRaw_, allCommandsRaw_;
+    QStringList m_userCommandsRaw, m_allCommandsRaw;
 
 
     /** For performance reasons, we don't immediately add new text
         to QTExtEdit. Instead we add it to pendingOutput_ and 
         flush it on timer.
     */
-    QString pendingOutput_;
-    QTimer updateTimer_;
+    QString m_pendingOutput;
+    QTimer m_updateTimer;
 
-    bool showInternalCommands_;
+    bool m_showInternalCommands;
 
-    int maxLines_;
+    int m_maxLines;
 
-    QColor gdbColor_;
-    QColor errorColor_;
+    QColor m_gdbColor;
+    QColor m_errorColor;
 };
 
-class OutputTextEdit : public QTextEdit
+class OutputTextEdit : public QPlainTextEdit
 {
     Q_OBJECT
 
 public:
     explicit OutputTextEdit(GDBOutputWidget* parent);
 
 protected:
     void contextMenuEvent(QContextMenuEvent* event) override;
 };
 
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 #endif