diff --git a/plugins/contextbrowser/browsemanager.cpp b/plugins/contextbrowser/browsemanager.cpp
index db83e8b654..843870d219 100644
--- a/plugins/contextbrowser/browsemanager.cpp
+++ b/plugins/contextbrowser/browsemanager.cpp
@@ -1,337 +1,331 @@
 /*
   * This file is part of KDevelop
  *
  * Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "browsemanager.h"
 
 #include <QApplication>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QMenuBar>
 
 #include <kparts/mainwindow.h>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include "contextbrowserview.h"
 #include <interfaces/iuicontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <ktexteditor/codecompletioninterface.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/forwarddeclaration.h>
 
 #include "contextbrowser.h"
 #include "debug.h"
 
 using namespace KDevelop;
 using namespace KTextEditor;
 
 EditorViewWatcher::EditorViewWatcher(QObject* parent)
     : QObject(parent)
 {
     connect(ICore::self()->documentController(), &IDocumentController::textDocumentCreated, this, &EditorViewWatcher::documentCreated);
     foreach(KDevelop::IDocument* document, ICore::self()->documentController()->openDocuments())
         documentCreated(document);
 }
 
 void EditorViewWatcher::documentCreated( KDevelop::IDocument* document ) {
     KTextEditor::Document* textDocument = document->textDocument();
     if(textDocument) {
         connect(textDocument, &Document::viewCreated, this, &EditorViewWatcher::viewCreated);
         foreach(KTextEditor::View* view, textDocument->views()) {
             Q_ASSERT(view->parentWidget());
             addViewInternal(view);
         }
     }
 }
 
 void EditorViewWatcher::addViewInternal(KTextEditor::View* view) {
     m_views << view;
     viewAdded(view);
     connect(view, &View::destroyed, this, &EditorViewWatcher::viewDestroyed);
 }
 
 void EditorViewWatcher::viewAdded(KTextEditor::View*) {
 }
 
 void EditorViewWatcher::viewDestroyed(QObject* view) {
     m_views.removeAll(static_cast<KTextEditor::View*>(view));
 }
 
 void EditorViewWatcher::viewCreated(KTextEditor::Document* /*doc*/, KTextEditor::View* view) {
     Q_ASSERT(view->parentWidget());
     addViewInternal(view);
 }
 
 QList<KTextEditor::View*> EditorViewWatcher::allViews() {
     return m_views;
 }
 
 void BrowseManager::eventuallyStartDelayedBrowsing() {
     avoidMenuAltFocus();
 
-    if(m_browsingByKey && m_browsingStartedInView)
+    if(m_browsingByKey == Qt::Key_Alt && m_browsingStartedInView)
         emit startDelayedBrowsing(m_browsingStartedInView);
 }
 
 BrowseManager::BrowseManager(ContextBrowserPlugin* controller)
     : QObject(controller)
     , m_plugin(controller)
     , m_browsing(false)
     , m_browsingByKey(0)
     , m_watcher(this)
 {
     m_delayedBrowsingTimer = new QTimer(this);
     m_delayedBrowsingTimer->setSingleShot(true);
 
     connect(m_delayedBrowsingTimer, &QTimer::timeout, this, &BrowseManager::eventuallyStartDelayedBrowsing);
 
     foreach(KTextEditor::View* view, m_watcher.allViews())
         viewAdded(view);
 }
 
 KTextEditor::View* viewFromWidget(QWidget* widget) {
     if(!widget)
         return 0;
     KTextEditor::View* view = qobject_cast<KTextEditor::View*>(widget);
     if(view)
         return view;
     else
         return viewFromWidget(widget->parentWidget());
 }
 
 BrowseManager::JumpLocation BrowseManager::determineJumpLoc(KTextEditor::Cursor textCursor, const QUrl& viewUrl) const {
     // @todo find out why this is needed, fix the code in kate
     if (textCursor.column() > 0) {
         textCursor.setColumn(textCursor.column() - 1);
     }
 
     // Step 1: Look for a special language object(Macro, included header, etc.)
     foreach (const auto& language, ICore::self()->languageController()->languagesForUrl(viewUrl)) {
         auto jumpTo = language->specialLanguageObjectJumpCursor(viewUrl, textCursor);
         if (jumpTo.first.isValid() && jumpTo.second.isValid()) {
             return {jumpTo};
         }
     }
 
     // Step 2: Look for a declaration/use
     DUChainReadLocker lock;
     // Jump to definition by default, unless a definition itself was selected,
     // in which case jump to declaration.
     if (auto selectedDeclaration = DUChainUtils::itemUnderCursor(viewUrl, textCursor)) {
         auto jumpDestination = selectedDeclaration;
         if (selectedDeclaration->isDefinition()) {
             // A definition was clicked directly - jump to declaration instead.
             if (auto declaration = DUChainUtils::declarationForDefinition(selectedDeclaration)) {
                 jumpDestination = declaration;
             }
         } else if (selectedDeclaration == DUChainUtils::declarationForDefinition(selectedDeclaration)) {
             // Clicked the declaration - jump to definition
             if (auto definition = FunctionDefinition::definition(selectedDeclaration)) {
                 jumpDestination = definition;
             }
         }
         return {{jumpDestination->url().toUrl(), jumpDestination->rangeInCurrentRevision().start()}};
     }
 
     return {};
 }
 
 bool BrowseManager::eventFilter(QObject * watched, QEvent * event) {
     QWidget* widget = qobject_cast<QWidget*>(watched);
     Q_ASSERT(widget);
 
     QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(event);
 
     const int browseKey = Qt::Key_Control;
     const int magicModifier = Qt::Key_Alt;
 
     KTextEditor::View* view = viewFromWidget(widget);
 
     //Eventually start key-browsing
     if(keyEvent && (keyEvent->key() == browseKey || keyEvent->key() == magicModifier) && !m_browsingByKey && keyEvent->type() == QEvent::KeyPress) {
         m_delayedBrowsingTimer->start(300); // always start the timer, to get consistent behavior regarding the ALT key and the menu activation
         m_browsingByKey = keyEvent->key();
 
         if(!view) {
             return false;
         }
 
         if(keyEvent->key() == magicModifier) {
             if(dynamic_cast<KTextEditor::CodeCompletionInterface*>(view) && dynamic_cast<KTextEditor::CodeCompletionInterface*>(view)->isCompletionActive())
             {
                 //Completion is active.
                 avoidMenuAltFocus();
             }else{
                 m_browsingStartedInView = view;
             }
         }
     }
 
     if(!view) {
         return false;
     }
 
     QFocusEvent* focusEvent = dynamic_cast<QFocusEvent*>(event);
     //Eventually stop key-browsing
     if((keyEvent && m_browsingByKey && keyEvent->key() == m_browsingByKey && keyEvent->type() == QEvent::KeyRelease)
         || (focusEvent && focusEvent->lostFocus())) {
         m_browsingByKey = 0;
         emit stopDelayedBrowsing();
     }
 
     QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
 
     if(mouseEvent) {
         if (mouseEvent->type() == QEvent::MouseButtonPress && mouseEvent->button() == Qt::XButton1) {
             m_plugin->historyPrevious();
             return true;
         }
         if (mouseEvent->type() == QEvent::MouseButtonPress && mouseEvent->button() == Qt::XButton2) {
             m_plugin->historyNext();
             return true;
         }
     }
 
     if(!m_browsing && !m_browsingByKey) {
         resetChangedCursor();
         return false;
     }
 
     if(mouseEvent) {
-        KTextEditor::View* iface = dynamic_cast<KTextEditor::View*>(view);
-        if(!iface) {
-            qCDebug(PLUGIN_CONTEXTBROWSER) << "Update kdelibs for the browsing-mode to work";
-            return false;
-        }
-
         QPoint coordinatesInView = widget->mapTo(view, mouseEvent->pos());
 
-        KTextEditor::Cursor textCursor = iface->coordinatesToCursor(coordinatesInView);
+        KTextEditor::Cursor textCursor = view->coordinatesToCursor(coordinatesInView);
         if (textCursor.isValid()) {
             JumpLocation jumpTo = determineJumpLoc(textCursor, view->document()->url());
             if (jumpTo.isValid()) {
                 if(mouseEvent->button() == Qt::LeftButton) {
                     if(mouseEvent->type() == QEvent::MouseButtonPress) {
                         m_buttonPressPosition = textCursor;
 //                         view->setCursorPosition(textCursor);
 //                         return false;
                     }else if(mouseEvent->type() == QEvent::MouseButtonRelease && textCursor == m_buttonPressPosition) {
                         ICore::self()->documentController()->openDocument(jumpTo.url, jumpTo.cursor);
 //                         event->accept();
 //                         return true;
                     }
                 }else if(mouseEvent->type() == QEvent::MouseMove) {
                     //Make the cursor a "hand"
                     setHandCursor(widget);
                     return false;
                 }
             }
         }
         resetChangedCursor();
     }
     return false;
 }
 
 void BrowseManager::resetChangedCursor() {
     QMap<QPointer<QWidget>, QCursor> cursors = m_oldCursors;
     m_oldCursors.clear();
 
     for(QMap<QPointer<QWidget>, QCursor>::iterator it = cursors.begin(); it != cursors.end(); ++it)
         if(it.key())
             it.key()->setCursor(QCursor(Qt::IBeamCursor));
 }
 
 void BrowseManager::setHandCursor(QWidget* widget) {
     if(m_oldCursors.contains(widget))
         return; //Nothing to do
     m_oldCursors[widget] = widget->cursor();
     widget->setCursor(QCursor(Qt::PointingHandCursor));
 }
 
 void BrowseManager::avoidMenuAltFocus() {
     // send an invalid key event to the main menu bar. The menu bar will
     // stop listening when observing another key than ALT between the press
     // and the release.
     QKeyEvent event1(QEvent::KeyPress, 0, Qt::NoModifier);
     QApplication::sendEvent(ICore::self()->uiController()->activeMainWindow()->menuBar(), &event1);
     QKeyEvent event2(QEvent::KeyRelease, 0, Qt::NoModifier);
     QApplication::sendEvent(ICore::self()->uiController()->activeMainWindow()->menuBar(), &event2);
 }
 
 void BrowseManager::applyEventFilter(QWidget* object, bool install) {
     if(install)
         object->installEventFilter(this);
     else
         object->removeEventFilter(this);
 
     foreach(QObject* child, object->children())
         if(qobject_cast<QWidget*>(child))
             applyEventFilter(qobject_cast<QWidget*>(child), install);
 }
 
 void BrowseManager::viewAdded(KTextEditor::View* view) {
     applyEventFilter(view, true);
     //We need to listen for cursorPositionChanged, to clear the shift-detector. The problem: Kate listens for the arrow-keys using shortcuts,
     //so those keys are not passed to the event-filter
 
     // can't use new signal/slot syntax here, these signals are only defined in KateView
     // TODO: should we really depend on kate internals here?
     connect(view, SIGNAL(navigateLeft()), m_plugin, SLOT(navigateLeft()));
     connect(view, SIGNAL(navigateRight()), m_plugin, SLOT(navigateRight()));
     connect(view, SIGNAL(navigateUp()), m_plugin, SLOT(navigateUp()));
     connect(view, SIGNAL(navigateDown()), m_plugin, SLOT(navigateDown()));
     connect(view, SIGNAL(navigateAccept()), m_plugin, SLOT(navigateAccept()));
     connect(view, SIGNAL(navigateBack()), m_plugin, SLOT(navigateBack()));
 }
 
 void Watcher::viewAdded(KTextEditor::View* view) {
     m_manager->viewAdded(view);
 }
 
 void BrowseManager::setBrowsing(bool enabled) {
     if(enabled == m_browsing)
         return;
     m_browsing = enabled;
 
     //This collects all the views
     if(enabled) {
         qCDebug(PLUGIN_CONTEXTBROWSER) << "Enabled browsing-mode";
     }else{
         qCDebug(PLUGIN_CONTEXTBROWSER) << "Disabled browsing-mode";
         resetChangedCursor();
     }
 }
 
 Watcher::Watcher(BrowseManager* manager)
     : EditorViewWatcher(manager), m_manager(manager) {
     foreach(KTextEditor::View* view, allViews())
         m_manager->applyEventFilter(view, true);
 }
 
 
diff --git a/shell/openprojectdialog.cpp b/shell/openprojectdialog.cpp
index ad50e4aca8..22b9ef6d8f 100644
--- a/shell/openprojectdialog.cpp
+++ b/shell/openprojectdialog.cpp
@@ -1,322 +1,341 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Andreas Pakulat <apaku@gmx.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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "openprojectdialog.h"
 #include "openprojectpage.h"
 #include "projectinfopage.h"
 
 #include <QFileInfo>
 #include <QFileDialog>
+#include <QDebug>
 
 #include <KColorScheme>
 #include <KIO/StatJob>
 #include <KIO/ListJob>
 #include <KJobWidgets>
 #include <KLocalizedString>
 
 #include "core.h"
 #include "uicontroller.h"
 #include "plugincontroller.h"
 #include "mainwindow.h"
 #include "shellextension.h"
 #include "projectsourcepage.h"
 #include <interfaces/iprojectcontroller.h>
 
 namespace
 {
 struct URLInfo
 {
     bool isValid;
     bool isDir;
     QString extension;
 };
 
 URLInfo getUrlInfo(const QUrl& url)
 {
     URLInfo ret;
     ret.isValid = false;
 
     if (url.isLocalFile()) {
         QFileInfo info(url.toLocalFile());
         ret.isValid = info.exists();
         if (ret.isValid) {
             ret.isDir = info.isDir();
             ret.extension = info.suffix();
         }
     } else if (url.isValid()) {
         KIO::StatJob* statJob = KIO::stat(url, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, KDevelop::Core::self()->uiControllerInternal()->defaultMainWindow());
         ret.isValid = statJob->exec(); // TODO: do this asynchronously so that the user isn't blocked while typing every letter of the hostname in sftp://hostname
         if (ret.isValid) {
             KIO::UDSEntry entry = statJob->statResult();
             ret.isDir = entry.isDir();
             ret.extension = QFileInfo(entry.stringValue(KIO::UDSEntry::UDS_NAME)).suffix();
         }
     }
     return ret;
 }
 }
 
 namespace KDevelop
 {
 
 OpenProjectDialog::OpenProjectDialog( bool fetch, const QUrl& startUrl, QWidget* parent )
     : KAssistantDialog( parent )
     , sourcePage(nullptr)
     , openPage(nullptr)
     , projectInfoPage(nullptr)
 {
     resize(QSize(700, 500));
 
     const bool useKdeFileDialog = qEnvironmentVariableIsSet("KDE_FULL_SESSION");
     QStringList filters, allEntry;
     QString filterFormat = useKdeFileDialog
                          ? QStringLiteral("%1|%2 (%1)")
                          : QStringLiteral("%2 (%1)");
     allEntry << "*." + ShellExtension::getInstance()->projectFileExtension();
     filters << filterFormat.arg("*." + ShellExtension::getInstance()->projectFileExtension(), ShellExtension::getInstance()->projectFileDescription());
     QVector<KPluginMetaData> plugins = ICore::self()->pluginController()->queryExtensionPlugins(QStringLiteral("org.kdevelop.IProjectFileManager"));
     foreach(const KPluginMetaData& info, plugins)
     {
         QStringList filter = KPluginMetaData::readStringList(info.rawData(), QStringLiteral("X-KDevelop-ProjectFilesFilter"));
         QString desc = info.value(QStringLiteral("X-KDevelop-ProjectFilesFilterDescription"));
 
-        if (!filter.isEmpty() && !desc.isEmpty()) {
-            m_projectFilters.insert(info.name(), filter);
-            allEntry += filter;
-            filters << filterFormat.arg(filter.join(QStringLiteral(" ")), desc);
-        }
+        m_projectFilters.insert(info.name(), filter);
+        m_projectPlugins.insert(info.name(), info);
+        allEntry += filter;
+        filters << filterFormat.arg(filter.join(QStringLiteral(" ")), desc);
     }
 
     if (useKdeFileDialog)
         filters.prepend(i18n("%1|All Project Files (%1)", allEntry.join(QStringLiteral(" "))));
-    else
-        filters.prepend(i18n("All Project Files (%1)", allEntry.join(QStringLiteral(" "))));
 
     QUrl start = startUrl.isValid() ? startUrl : Core::self()->projectController()->projectsBaseDirectory();
     start = start.adjusted(QUrl::NormalizePathSegments);
     KPageWidgetItem* currentPage = 0;
 
     if( fetch ) {
         sourcePageWidget = new ProjectSourcePage( start, this );
         connect( sourcePageWidget, &ProjectSourcePage::isCorrect, this, &OpenProjectDialog::validateSourcePage );
         sourcePage = addPage( sourcePageWidget, i18n("Select Source") );
         currentPage = sourcePage;
     }
 
     if (useKdeFileDialog) {
         openPageWidget = new OpenProjectPage( start, filters, this );
         connect( openPageWidget, &OpenProjectPage::urlSelected, this, &OpenProjectDialog::validateOpenUrl );
         connect( openPageWidget, &OpenProjectPage::accepted, this, &OpenProjectDialog::openPageAccepted );
         openPage = addPage( openPageWidget, i18n("Select a build system setup file, existing KDevelop project, "
                                                  "or any folder to open as a project") );
 
         if (!currentPage) {
             currentPage = openPage;
         }
     } else {
         nativeDialog = new QFileDialog(this, i18n("Open Project"));
         nativeDialog->setDirectoryUrl(start);
-        nativeDialog->setFileMode(QFileDialog::ExistingFile);
-        nativeDialog->setNameFilters(filters);
+        nativeDialog->setFileMode(QFileDialog::Directory);
     }
 
     ProjectInfoPage* page = new ProjectInfoPage( this );
     connect( page, &ProjectInfoPage::projectNameChanged, this, &OpenProjectDialog::validateProjectName );
     connect( page, &ProjectInfoPage::projectManagerChanged, this, &OpenProjectDialog::validateProjectManager );
     projectInfoPage = addPage( page, i18n("Project Information") );
 
     if (!currentPage) {
         currentPage = projectInfoPage;
     }
 
     setValid( sourcePage, false );
     setValid( openPage, false );
     setValid( projectInfoPage, false);
     setAppropriate( projectInfoPage, false );
 
     setCurrentPage( currentPage );
     setWindowTitle(i18n("Open Project"));
 }
 
 bool OpenProjectDialog::execNativeDialog()
 {
     while (true)
     {
         if (nativeDialog->exec()) {
             QUrl selectedUrl = nativeDialog->selectedUrls().at(0);
             if (getUrlInfo(selectedUrl).isValid) {
                 // validate directory first to populate m_projectName and m_projectManager
                 validateOpenUrl(selectedUrl.adjusted(QUrl::RemoveFilename));
                 validateOpenUrl(selectedUrl);
                 return true;
             }
         }
         else {
             return false;
         }
     }
 }
 
 int OpenProjectDialog::exec()
 {
     if (nativeDialog && !execNativeDialog()) {
         reject();
         return QDialog::Rejected;
     }
     return KAssistantDialog::exec();
 }
 
 void OpenProjectDialog::validateSourcePage(bool valid)
 {
     setValid(sourcePage, valid);
     openPageWidget->setUrl(sourcePageWidget->workingDir());
 }
 
 void OpenProjectDialog::validateOpenUrl( const QUrl& url_ )
 {
     URLInfo urlInfo = getUrlInfo(url_);
 
     const QUrl url = url_.adjusted(QUrl::StripTrailingSlash);
 
     // openPage is used only in KDE
     if (openPage) {
         if ( urlInfo.isValid ) {
             // reset header
             openPage->setHeader(i18n("Open \"%1\" as project", url.fileName()));
         } else {
             // report error
             KColorScheme scheme(palette().currentColorGroup());
             const QString errorMsg = i18n("Selected URL is invalid");
             openPage->setHeader(QStringLiteral("<font color='%1'>%2</font>")
                 .arg(scheme.foreground(KColorScheme::NegativeText).color().name(), errorMsg)
             );
             setAppropriate( projectInfoPage, false );
             setAppropriate( openPage, true );
             setValid( openPage, false );
             return;
         }
     }
 
     m_selected = url;
 
     if( urlInfo.isDir || urlInfo.extension != ShellExtension::getInstance()->projectFileExtension() )
     {
         setAppropriate( projectInfoPage, true );
         m_url = url;
         if( !urlInfo.isDir ) {
             m_url = m_url.adjusted(QUrl::StripTrailingSlash | QUrl::RemoveFilename);
         }
         ProjectInfoPage* page = qobject_cast<ProjectInfoPage*>( projectInfoPage->widget() );
         if( page )
         {
             page->setProjectName( m_url.fileName() );
-            // Default manager
-            page->setProjectManager( QStringLiteral("Generic Project Manager") );
             // clear the filelist
             m_fileList.clear();
 
             if( urlInfo.isDir ) {
                 // If a dir was selected fetch all files in it
                 KIO::ListJob* job = KIO::listDir( m_url );
                 connect( job, &KIO::ListJob::entries,
                                 this, &OpenProjectDialog::storeFileList);
                 KJobWidgets::setWindow(job, Core::self()->uiController()->activeMainWindow());
                 job->exec();
             } else {
-                // Else we'lll just take the given file
+                // Else we'll just take the given file
                 m_fileList << url.fileName();
             }
             // Now find a manager for the file(s) in our filelist.
-            bool managerFound = false;
-            foreach( const QString& manager, m_projectFilters.keys() )
-            {
-                foreach( const QString& filterexp, m_projectFilters.value(manager) )
-                {
-                    if( !m_fileList.filter( QRegExp( filterexp, Qt::CaseSensitive, QRegExp::Wildcard ) ).isEmpty() )
-                    {
-                        managerFound = true;
-                        break;
-                    }
+            QVector<ProjectFileChoice> choices;
+            Q_FOREACH ( const auto& file, m_fileList ) {
+                auto plugins = projectManagerForFile(file);
+                if ( plugins.contains("<built-in>") ) {
+                    plugins.removeAll("<built-in>");
+                    choices.append({i18n("Open existing file \"%1\"", file), "<built-in>", QString()});
+                }
+                Q_FOREACH ( const auto& plugin, plugins ) {
+                    auto meta = m_projectPlugins.value(plugin);
+                    choices.append({file + QString(" (%1)").arg(plugin), meta.pluginId(), meta.iconName()});
                 }
-                if( managerFound ) {
-                    page->setProjectManager( manager );
-                    break;
+            }
+            Q_FOREACH ( const auto& plugin, m_projectFilters.keys() ) {
+                qDebug() << plugin << m_projectFilters.value(plugin);
+                if ( m_projectFilters.value(plugin).isEmpty() ) {
+                    // that works in any case
+                    auto meta = m_projectPlugins.value(plugin);
+                    choices.append({plugin, meta.pluginId(), meta.iconName()});
                 }
             }
+            page->populateProjectFileCombo(choices);
         }
         m_url.setPath( m_url.path() + '/' + m_url.fileName() + '.' + ShellExtension::getInstance()->projectFileExtension() );
     } else {
         setAppropriate( projectInfoPage, false );
         m_url = url;
     }
     validateProjectInfo();
     setValid( openPage, true );
 }
 
+QStringList OpenProjectDialog::projectManagerForFile(const QString& file) const
+{
+    QStringList ret;
+    foreach( const QString& manager, m_projectFilters.keys() )
+    {
+        foreach( const QString& filterexp, m_projectFilters.value(manager) )
+        {
+            QRegExp exp( filterexp, Qt::CaseSensitive, QRegExp::Wildcard );
+            if ( exp.exactMatch(file) ) {
+                ret.append(manager);
+            }
+        }
+    }
+    if ( file.endsWith(ShellExtension::getInstance()->projectFileExtension()) ) {
+        ret.append("<built-in>");
+    }
+    return ret;
+}
+
 void OpenProjectDialog::openPageAccepted()
 {
     if ( isValid( openPage ) ) {
         next();
     }
 }
 
 void OpenProjectDialog::validateProjectName( const QString& name )
 {
     m_projectName = name;
     validateProjectInfo();
 }
 
 void OpenProjectDialog::validateProjectInfo()
 {
     setValid( projectInfoPage, (!projectName().isEmpty() && !projectManager().isEmpty()) );
 }
 
 void OpenProjectDialog::validateProjectManager( const QString& manager )
 {
     m_projectManager = manager;
     validateProjectInfo();
 }
 
 QUrl OpenProjectDialog::projectFileUrl() const
 {
     return m_url;
 }
 
 QUrl OpenProjectDialog::selectedUrl() const
 {
     return m_selected;
 }
 
 QString OpenProjectDialog::projectName() const
 {
     return m_projectName;
 }
 
 QString OpenProjectDialog::projectManager() const
 {
     return m_projectManager;
 }
 
 void OpenProjectDialog::storeFileList(KIO::Job*, const KIO::UDSEntryList& list)
 {
     foreach( const KIO::UDSEntry& entry, list )
     {
         QString name = entry.stringValue( KIO::UDSEntry::UDS_NAME );
         if( name != QLatin1String(".") && name != QLatin1String("..") && !entry.isDir() )
         {
             m_fileList << name;
         }
     }
 }
 
 }
 
 
diff --git a/shell/openprojectdialog.h b/shell/openprojectdialog.h
index d39ff8e08b..78f5ccf9e0 100644
--- a/shell/openprojectdialog.h
+++ b/shell/openprojectdialog.h
@@ -1,82 +1,86 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Andreas Pakulat <apaku@gmx.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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KDEVPLATFORM_OPENPROJECTDIALOG_H
 #define KDEVPLATFORM_OPENPROJECTDIALOG_H
 
 #include <QUrl>
 
 #include <KAssistantDialog>
 #include <KIO/UDSEntry>
+#include <KPluginMetaData>
 
 class KPageWidgetItem;
 class QFileDialog;
 namespace KIO
 {
 class Job;
 }
 
 namespace KDevelop
 {
 class ProjectSourcePage;
 class OpenProjectPage;
 
 class OpenProjectDialog : public KAssistantDialog
 {
     Q_OBJECT
 
 public:
     OpenProjectDialog( bool fetch, const QUrl& startUrl, QWidget* parent = nullptr );
 
     /**
     * Return a QUrl pointing to the project's .kdev file.
     */
     QUrl projectFileUrl() const;
     /**
     * Return a QUrl pointing to the file, that was selected by the user.
     * Unlike projectFileUrl(), this can be a .kdev file, as well
     * as build system file (e.g. CMakeLists.txt).
     */
     QUrl selectedUrl() const;
     QString projectName() const;
     QString projectManager() const;
 
     int exec() override;
 
+    QStringList projectManagerForFile(const QString& file) const;
+
 private slots:
     void validateSourcePage( bool );
     void validateOpenUrl( const QUrl& );
     void validateProjectName( const QString& );
     void validateProjectManager( const QString& );
     void storeFileList(KIO::Job*, const KIO::UDSEntryList&);
     void openPageAccepted();
 
 private:
     bool execNativeDialog();
     void validateProjectInfo();
     QUrl m_url;
     QUrl m_selected;
     QString m_projectName;
     QString m_projectManager;
     /// Used to select files when we aren't in KDE
     QFileDialog* nativeDialog = nullptr;
     KPageWidgetItem* sourcePage;
     KPageWidgetItem* openPage;
     KPageWidgetItem* projectInfoPage;
     QStringList m_fileList;
     QMap<QString, QStringList> m_projectFilters;
+    QMap<QString, KPluginMetaData> m_projectPlugins;
 
     KDevelop::OpenProjectPage* openPageWidget = nullptr;
     KDevelop::ProjectSourcePage* sourcePageWidget = nullptr;
 };
 
 }
 
 #endif
diff --git a/shell/projectcontroller.cpp b/shell/projectcontroller.cpp
index fe704c36f3..fe317d6df0 100644
--- a/shell/projectcontroller.cpp
+++ b/shell/projectcontroller.cpp
@@ -1,1195 +1,1198 @@
 
 /* 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 <QItemSelectionModel>
 #include <QLabel>
 #include <QList>
 #include <QMap>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QSet>
 #include <QTemporaryFile>
 #include <QVBoxLayout>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #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 <interfaces/ilanguagecontroller.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/backgroundparser/parseprojectjob.h>
 #include <interfaces/iruncontroller.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;
     Core* m_core;
 //     IProject* m_currentProject;
     ProjectModel* model;
     QItemSelectionModel* selectionModel;
     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
     IProject* m_configuringProject;
     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
     QPointer<ProjectChangesModel> m_changesModel;
     QHash< IProject*, QPointer<KJob> > m_parseJobs; // parse jobs that add files from the project to the background parser.
 
     ProjectControllerPrivate( ProjectController* p )
         : m_core(0), model(0), selectionModel(0), dialog(0), m_configuringProject(0), q(p), buildset(0), 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;
 
         QVector<KDevelop::ConfigPage*> configPages;
         auto mainWindow = m_core->uiController()->activeMainWindow();
 
         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, mainWindow));
             }
         }
 
         Q_ASSERT(!m_configuringProject);
         m_configuringProject = proj;
         KDevelop::ConfigDialog cfgDlg(configPages, mainWindow);
         QObject::connect(&cfgDlg, &ConfigDialog::configSaved, &cfgDlg, [this](ConfigPage* page) {
             Q_UNUSED(page)
             Q_ASSERT_X(m_configuringProject, Q_FUNC_INFO,
                     "ConfigDialog signalled project config change, but no project set for configuring!");
             emit q->projectConfigurationChanged(m_configuringProject);
         });
         cfgDlg.setWindowTitle(i18n("Configure Project %1", proj->name()));
         cfgDlg.exec();
         proj->projectConfiguration()->sync();
         m_configuringProject = nullptr;
 
     }
 
     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 )
     {
         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( Context* ctx )
     {
         ProjectItemContext* itemctx = dynamic_cast<ProjectItemContext*>(ctx);
         m_openConfig->setEnabled( itemctx && itemctx->items().count() == 1 );
         m_closeProject->setEnabled( itemctx && itemctx->items().count() > 0 );
     }
 
     void openProjectConfig()
     {
         ProjectItemContext* ctx = dynamic_cast<ProjectItemContext*>( Core::self()->selectionController()->currentSelection() );
         if( ctx && ctx->items().count() == 1 )
         {
             q->configureProject( ctx->items().at(0)->project() );
         }
     }
 
     void closeSelectedProjects()
     {
         ProjectItemContext* ctx =  dynamic_cast<ProjectItemContext*>( Core::self()->selectionController()->currentSelection() );
         if( ctx && ctx->items().count() > 0 )
         {
             QSet<IProject*> projects;
             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);
         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)
 {
     Q_ASSERT(d);
     OpenProjectDialog dlg( fetch, startUrl, 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() == "<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) {
         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") );
 
     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;
     delete d;
 }
 
 void ProjectController::cleanup()
 {
     if ( d->m_currentlyOpening.isEmpty() ) {
         d->saveListOfOpenedProjects();
     }
 
     d->m_cleaningUp = true;
     if( buildSetModel() ) {
         buildSetModel()->storeToSession( Core::self()->activeSession() );
     }
 
     closeAllProjects();
 }
 
 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->selectionModel = new QItemSelectionModel(d->model);
 
     loadSettings(false);
     d->dialog = new ProjectDialogProvider(d);
 
     QDBusConnection::sessionBus().registerObject( QStringLiteral("/org/kdevelop/ProjectController"),
         this, QDBusConnection::ExportScriptableSlots );
 
     KSharedConfigPtr config = Core::self()->activeSession()->config();
     KConfigGroup group = config->group( "General Options" );
     QList<QUrl> openProjects = group.readEntry( "Open Projects", QList<QUrl>() );
 
     QMetaObject::invokeMethod(this, "openProjects", Qt::QueuedConnection, Q_ARG(QList<QUrl>, openProjects));
 
     connect( Core::self()->selectionController(), &ISelectionController::selectionChanged,
              this, [&] (Context* ctx) { d->updateActionStates(ctx); } );
 }
 
 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 0;
 }
 
 QList<IProject*> ProjectController::projects() const
 {
     return d->m_projects;
 }
 
 void ProjectController::eventuallyOpenProjectFile(KIO::Job* _job, 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.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() ) {
         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, &QDialog::accept);
         connect(buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
         mainLayout->addWidget(buttonBox);
 
         bool success = dialog.exec();
         if (!success)
             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);
     }
 }
 
 void ProjectController::fetchProject()
 {
     QUrl url = d->dialog->askProjectConfigLocation(true);
 
     if ( !url.isEmpty() )
     {
         d->importProject(url);
     }
 }
 
 void ProjectController::projectImportingFinished( IProject* project )
 {
     if( !project )
     {
         qWarning() << "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 );
 
     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();
     }
 
     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 0;
     }
 
     ProjectBaseItem* item = d->model->itemForPath(IndexedString(url));
     if (item) {
         return item->project();
     }
     return 0;
 }
 
 IProject* ProjectController::findProjectByName( const QString& name )
 {
     Q_FOREACH( IProject* proj, d->m_projects )
     {
         if( proj->name() == name )
         {
             return proj;
         }
     }
     return 0;
 }
 
 
 void ProjectController::configureProject( IProject* project )
 {
     d->projectConfig( project );
 }
 
 void ProjectController::addProject(IProject* project)
 {
     Q_ASSERT(project);
     if (d->m_projects.contains(project)) {
         qWarning() << "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);
 }
 
 QItemSelectionModel* ProjectController::projectSelectionModel()
 {
     return d->selectionModel;
 }
 
 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() + "/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 = "<i>" +  project->name() + "</i>/";
         } else {
             prefixText = project->name() + ':';
         }
         QString relativePath = project->path().relativePath(parent);
         if(relativePath.startsWith(QLatin1String("./"))) {
             relativePath = relativePath.mid(2);
         }
         if (!relativePath.isEmpty()) {
             prefixText += relativePath + '/';
         }
     } else {
         prefixText = parent.pathOrUrl() + '/';
     }
     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 "<i>" +  project->name() + "</i>";
         } else {
             return project->name();
         }
     }
 
     QString prefixText = prettyFilePath( url, format );
     if (format == FormatHtml) {
         return prefixText + "<b>" + url.fileName() + "</b>";
     } else {
         return prefixText + url.fileName();
     }
 }
 
 ContextMenuExtension ProjectController::contextMenuExtension ( Context* ctx )
 {
     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);
     return ext;
 }
 
 ProjectBuildSetModel* ProjectController::buildSetModel()
 {
     return d->buildset;
 }
 
 ProjectChangesModel* ProjectController::changesModel()
 {
     if(!d->m_changesModel)
         d->m_changesModel=new ProjectChangesModel(this);
 
     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) {
                 VcsCommitDialog *commitDialog = new VcsCommitDialog(patchSource);
                 commitDialog->setCommitCandidates(patchSource->infos());
                 commitDialog->exec();
             }
         }
     }
 }
 
 QString ProjectController::mapSourceBuild( const QString& path_, bool reverse, bool fallbackRoot ) const
 {
     Path path(path_);
     IProject* sourceDirProject = 0, *buildDirProject = 0;
     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]);
 }
 
 }
 
 #include "moc_projectcontroller.cpp"
diff --git a/shell/projectinfopage.cpp b/shell/projectinfopage.cpp
index fb440fd562..ff755a83f5 100644
--- a/shell/projectinfopage.cpp
+++ b/shell/projectinfopage.cpp
@@ -1,62 +1,57 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Andreas Pakulat <apaku@gmx.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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "projectinfopage.h"
 #include "ui_projectinfopage.h"
 
 #include "core.h"
 #include "plugincontroller.h"
 
 namespace KDevelop
 {
 
 ProjectInfoPage::ProjectInfoPage( QWidget* parent )
         : QWidget( parent )
 {
     page_ui = new Ui::ProjectInfoPage;
     page_ui->setupUi( this );
     connect( page_ui->nameEdit, &QLineEdit::textEdited, 
              this, &ProjectInfoPage::projectNameChanged );
     connect( page_ui->managerCombo, static_cast<void(QComboBox::*)(int)>(&QComboBox::activated),
              this, &ProjectInfoPage::changeProjectManager );
-    QVector<KPluginMetaData> data = Core::self()->pluginControllerInternal()->queryExtensionPlugins(QStringLiteral("org.kdevelop.IProjectFileManager"));
-    foreach (auto&& info, data) {
-        page_ui->managerCombo->addItem(QIcon::fromTheme(info.iconName()), info.name(), info.pluginId());
-    }
 }
 
 ProjectInfoPage::~ProjectInfoPage()
 {
     delete page_ui;
 }
 
 void ProjectInfoPage::changeProjectManager( int idx )
 {
     emit projectManagerChanged( page_ui->managerCombo->itemData( idx ).toString() );
 }
 
 void ProjectInfoPage::setProjectName( const QString& name )
 {
     page_ui->nameEdit->setText( name );
     emit projectNameChanged( page_ui->nameEdit->text() );
 }
 
-void ProjectInfoPage::setProjectManager( const QString& name )
+void ProjectInfoPage::populateProjectFileCombo(const QVector<ProjectFileChoice>& choices)
 {
-    int idx = page_ui->managerCombo->findText( name );
-    if( idx != -1 )
-    {
-        page_ui->managerCombo->setCurrentIndex( idx );
-        changeProjectManager( idx );
+    page_ui->managerCombo->clear();
+    Q_FOREACH ( const auto& item, choices ) {
+        page_ui->managerCombo->addItem(QIcon::fromTheme(item.iconName), item.text, item.pluginId);
     }
+    changeProjectManager(0);
 }
 
 }
 
diff --git a/shell/projectinfopage.h b/shell/projectinfopage.h
index 92183be6e6..21787a7ebe 100644
--- a/shell/projectinfopage.h
+++ b/shell/projectinfopage.h
@@ -1,43 +1,49 @@
 /***************************************************************************
  *   Copyright (C) 2008 by Andreas Pakulat <apaku@gmx.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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KDEVPLATFORM_PROJECTINFOPAGE_H
 #define KDEVPLATFORM_PROJECTINFOPAGE_H
 
 #include <QWidget>
 
+struct ProjectFileChoice {
+    QString text;
+    QString pluginId;
+    QString iconName;
+};
+
 namespace Ui
 {
     class ProjectInfoPage;
 }
 
 namespace KDevelop
 {
 
 class ProjectInfoPage : public QWidget
 {
 Q_OBJECT
 public:
     explicit ProjectInfoPage( QWidget* parent = nullptr );
     ~ProjectInfoPage() override;
     void setProjectName( const QString& );
-    void setProjectManager( const QString& );
+    void populateProjectFileCombo( const QVector<ProjectFileChoice>& choices );
 signals:
     void projectNameChanged( const QString& );
     void projectManagerChanged( const QString& );
 private slots:
     void changeProjectManager( int );
 private:
     Ui::ProjectInfoPage* page_ui;
 };
 
 }
 
 #endif
diff --git a/shell/projectinfopage.ui b/shell/projectinfopage.ui
index d7b1cb83bd..0868ac9412 100644
--- a/shell/projectinfopage.ui
+++ b/shell/projectinfopage.ui
@@ -1,64 +1,65 @@
-<ui version="4.0" >
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
  <class>ProjectInfoPage</class>
- <widget class="QWidget" name="ProjectInfoPage" >
-  <property name="geometry" >
+ <widget class="QWidget" name="ProjectInfoPage">
+  <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>300</height>
+    <width>651</width>
+    <height>416</height>
    </rect>
   </property>
-  <layout class="QGridLayout" name="gridLayout" >
-   <item row="0" column="0" >
-    <widget class="QLabel" name="label" >
-     <property name="toolTip" >
-      <string>Provide a name for the project</string>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0">
+    <widget class="QLabel" name="label_2">
+     <property name="toolTip">
+      <string>Select the Management Plugin to use for this project</string>
      </property>
-     <property name="text" >
-      <string>Name:</string>
+     <property name="text">
+      <string>Project manager:</string>
      </property>
     </widget>
    </item>
-   <item row="0" column="1" >
-    <widget class="QLineEdit" name="nameEdit" >
-     <property name="toolTip" >
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
+     <property name="toolTip">
       <string>Provide a name for the project</string>
      </property>
-    </widget>
-   </item>
-   <item row="1" column="0" >
-    <widget class="QLabel" name="label_2" >
-     <property name="toolTip" >
-      <string>Select the Management Plugin to use for this project</string>
-     </property>
-     <property name="text" >
-      <string>Build System:</string>
+     <property name="text">
+      <string>Name:</string>
      </property>
     </widget>
    </item>
-   <item row="1" column="1" >
-    <widget class="QComboBox" name="managerCombo" >
-     <property name="toolTip" >
-      <string>Select the Management Plugin to use for this project</string>
+   <item row="0" column="2">
+    <widget class="QLineEdit" name="nameEdit">
+     <property name="toolTip">
+      <string>Provide a name for the project</string>
      </property>
     </widget>
    </item>
-   <item row="2" column="1" >
-    <spacer name="verticalSpacer" >
-     <property name="orientation" >
+   <item row="2" column="2">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
-     <property name="sizeHint" stdset="0" >
+     <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
+   <item row="1" column="2">
+    <widget class="QComboBox" name="managerCombo">
+     <property name="toolTip">
+      <string>Select the Management Plugin to use for this project</string>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>