diff --git a/plugins/documentview/kdevdocumentview.cpp b/plugins/documentview/kdevdocumentview.cpp
index 97601f04a4..932f9f3b17 100644
--- a/plugins/documentview/kdevdocumentview.cpp
+++ b/plugins/documentview/kdevdocumentview.cpp
@@ -1,369 +1,365 @@
 /* This file is part of KDevelop
 Copyright 2005 Adam Treat <treat@kde.org>
 Copyright 2013 Sebastian Kügler <sebas@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #include "kdevdocumentview.h"
 #include "kdevdocumentviewplugin.h"
 #include "kdevdocumentmodel.h"
 
 #include <QAction>
 #include <QContextMenuEvent>
 #include <QFileInfo>
 #include <QHeaderView>
 #include <QMenu>
 #include <QSortFilterProxyModel>
 
 #include <KLocalizedString>
 #include <KStandardAction>
-#include <KSharedConfig>
-#include <KConfigGroup>
 
 #include "kdevdocumentselection.h"
 #include "kdevdocumentviewdelegate.h"
 
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/context.h>
 #include <interfaces/idocument.h>
 
 #include <widgetcolorizer.h>
 #include <path.h>
 
 using namespace KDevelop;
 
 KDevDocumentView::KDevDocumentView( KDevDocumentViewPlugin *plugin, QWidget *parent )
     : QTreeView( parent ),
         m_plugin( plugin )
 {
     connect(ICore::self()->projectController(), &IProjectController::projectOpened,
             this, &KDevDocumentView::updateProjectPaths);
     connect(ICore::self()->projectController(), &IProjectController::projectClosed,
             this, &KDevDocumentView::updateProjectPaths);
 
     m_documentModel = new KDevDocumentModel(this);
 
     m_delegate = new KDevDocumentViewDelegate( this );
 
     m_proxy = new QSortFilterProxyModel( this );
     m_proxy->setSourceModel( m_documentModel );
     m_proxy->setDynamicSortFilter( true );
     m_proxy->setSortCaseSensitivity( Qt::CaseInsensitive );
     m_proxy->sort(0);
 
     m_selectionModel = new KDevDocumentSelection( m_proxy );
 
     setModel( m_proxy );
     setSelectionModel( m_selectionModel );
     setItemDelegate( m_delegate );
 
     setObjectName( i18n( "Documents" ) );
 
     setWindowIcon( QIcon::fromTheme( QStringLiteral( "document-multiple" ), windowIcon() ) );
     setWindowTitle( i18n( "Documents" ) );
 
     setFocusPolicy( Qt::NoFocus );
 
     header()->hide();
 
     setSelectionBehavior( QAbstractItemView::SelectRows );
     setSelectionMode( QAbstractItemView::ExtendedSelection );
 
     updateProjectPaths();
 }
 
 KDevDocumentView::~KDevDocumentView()
 {}
 
 KDevDocumentViewPlugin *KDevDocumentView::plugin() const
 {
     return m_plugin;
 }
 
 void KDevDocumentView::mousePressEvent( QMouseEvent * event )
 {
     QModelIndex proxyIndex = indexAt( event->pos() );
     QModelIndex index = m_proxy->mapToSource( proxyIndex );
 
     if (event->button() == Qt::LeftButton && event->modifiers() == Qt::NoModifier) {
         if (proxyIndex.parent().isValid()) {
             // this is a document item
             KDevelop::IDocumentController* dc = m_plugin->core()->documentController();
             QUrl documentUrl = static_cast<KDevDocumentItem*>(m_documentModel->itemFromIndex(index))->fileItem()->url();
             if (dc->documentForUrl(documentUrl) != dc->activeDocument()) {
                 dc->openDocument(documentUrl);
                 return;
             }
         } else {
             // this is a folder item
             setExpanded(proxyIndex, !isExpanded(proxyIndex));
             return;
         }
     }
 
     QTreeView::mousePressEvent( event );
 }
 
 template<typename F> void KDevDocumentView::visitItems(F f, bool selectedItems)
 {
     KDevelop::IDocumentController* dc = m_plugin->core()->documentController();
     QList<QUrl> docs = selectedItems ? m_selectedDocs : m_unselectedDocs;
 
     foreach(const QUrl& url, docs) {
        KDevelop::IDocument* doc = dc->documentForUrl(url);
        if (doc) f(doc);
     }
 }
 
 namespace
 {
 class DocSaver
 {
 public: void operator()(KDevelop::IDocument* doc) { doc->save(); }
 };
 class DocCloser
 {
 public: void operator()(KDevelop::IDocument* doc) { doc->close(); }
 };
 class DocReloader
 {
 public: void operator()(KDevelop::IDocument* doc) { doc->reload(); }
 };
 }
 
 void KDevDocumentView::saveSelected()
 {
     visitItems(DocSaver(), true);
 }
 
 void KDevDocumentView::closeSelected()
 {
     visitItems(DocCloser(), true);
 }
 
 void KDevDocumentView::closeUnselected()
 {
     visitItems(DocCloser(), false);
 }
 
 void KDevDocumentView::reloadSelected()
 {
     visitItems(DocReloader(), true);
 }
 
 void KDevDocumentView::contextMenuEvent( QContextMenuEvent * event )
 {
     QModelIndex proxyIndex = indexAt( event->pos() );
     // for now, ignore clicks on empty space or folder items
     if (!proxyIndex.isValid() || !proxyIndex.parent().isValid()) {
         return;
     }
 
     updateSelectedDocs();
 
     if (!m_selectedDocs.isEmpty())
     {
         QMenu* ctxMenu = new QMenu(this);
 
         KDevelop::FileContext context(m_selectedDocs);
         QList<KDevelop::ContextMenuExtension> extensions =
             m_plugin->core()->pluginController()->queryPluginsForContextMenuExtensions( &context );
 
         QList<QAction*> vcsActions;
         QList<QAction*> fileActions;
         QList<QAction*> editActions;
         QList<QAction*> extensionActions;
         foreach( const KDevelop::ContextMenuExtension& ext, extensions )
         {
             fileActions += ext.actions(KDevelop::ContextMenuExtension::FileGroup);
             vcsActions += ext.actions(KDevelop::ContextMenuExtension::VcsGroup);
             editActions += ext.actions(KDevelop::ContextMenuExtension::EditGroup);
             extensionActions += ext.actions(KDevelop::ContextMenuExtension::ExtensionGroup);
         }
 
         appendActions(ctxMenu, fileActions);
 
         QAction* save = KStandardAction::save(this, SLOT(saveSelected()), ctxMenu);
         save->setEnabled(selectedDocHasChanges());
         ctxMenu->addAction(save);
         ctxMenu->addAction(QIcon::fromTheme(QStringLiteral("view-refresh")), i18n( "Reload" ), this, SLOT(reloadSelected()));
 
         appendActions(ctxMenu, editActions);
 
         ctxMenu->addAction(KStandardAction::close(this, SLOT(closeSelected()), ctxMenu));
         QAction* closeUnselected = ctxMenu->addAction(QIcon::fromTheme(QStringLiteral("document-close")), i18n( "Close Other Files" ), this, SLOT(closeUnselected()));
         closeUnselected->setEnabled(!m_unselectedDocs.isEmpty());
 
         appendActions(ctxMenu, vcsActions);
 
         appendActions(ctxMenu, extensionActions);
 
         connect(ctxMenu, &QMenu::aboutToHide, ctxMenu, &QMenu::deleteLater);
         ctxMenu->popup( event->globalPos() );
     }
 }
 
 void KDevDocumentView::appendActions(QMenu* menu, const QList<QAction*>& actions)
 {
     foreach( QAction* act, actions )
     {
         menu->addAction(act);
     }
     menu->addSeparator();
 }
 
 bool KDevDocumentView::selectedDocHasChanges()
 {
     KDevelop::IDocumentController* dc = m_plugin->core()->documentController();
     foreach(const QUrl& url, m_selectedDocs)
     {
         KDevelop::IDocument* doc = dc->documentForUrl(url);
         if (!doc) continue;
         if (doc->state() != KDevelop::IDocument::Clean)
         {
             return true;
         }
     }
     return false;
 }
 
 void KDevDocumentView::updateSelectedDocs()
 {
     m_selectedDocs.clear();
     m_unselectedDocs.clear();
 
     QList<QStandardItem*> allItems = m_documentModel->findItems(QStringLiteral("*"), Qt::MatchWildcard | Qt::MatchRecursive);
     foreach (QStandardItem* item, allItems)
     {
         if (KDevFileItem * fileItem = dynamic_cast<KDevDocumentItem*>(item)->fileItem())
         {
             if (m_selectionModel->isSelected(m_proxy->mapFromSource(m_documentModel->indexFromItem(fileItem))))
                 m_selectedDocs << fileItem->url();
             else
                 m_unselectedDocs << fileItem->url();
         }
     }
 }
 
 void KDevDocumentView::activated( KDevelop::IDocument* document )
 {
     setCurrentIndex( m_proxy->mapFromSource( m_documentModel->indexFromItem( m_doc2index[ document ] ) ) );
 }
 
 void KDevDocumentView::saved( KDevelop::IDocument* )
 {
 }
 
 void KDevDocumentView::opened( KDevelop::IDocument* document )
 {
     const QString path = QFileInfo( document->url().path() ).path();
 
     KDevCategoryItem *categoryItem = m_documentModel->category( path );
     if ( !categoryItem )
     {
         categoryItem = new KDevCategoryItem( path );
         categoryItem->setUrl( document->url() );
         m_documentModel->insertRow( m_documentModel->rowCount(), categoryItem );
         setExpanded( m_proxy->mapFromSource( m_documentModel->indexFromItem( categoryItem ) ), false);
         updateCategoryItem( categoryItem );
     }
 
     if ( !categoryItem->file( document->url() ) )
     {
         KDevFileItem * fileItem = new KDevFileItem( document->url() );
         categoryItem->setChild( categoryItem->rowCount(), fileItem );
         setCurrentIndex( m_proxy->mapFromSource( m_documentModel->indexFromItem( fileItem ) ) );
         m_doc2index[ document ] = fileItem;
     }
 }
 
 void KDevDocumentView::closed( KDevelop::IDocument* document )
 {
     KDevFileItem* file = m_doc2index[ document ];
     if ( !file )
         return;
 
     QStandardItem* categoryItem = file->parent();
 
     qDeleteAll(categoryItem->takeRow(m_documentModel->indexFromItem(file).row()));
 
     m_doc2index.remove(document);
 
     if ( categoryItem->hasChildren() )
         return;
 
     qDeleteAll(m_documentModel->takeRow(m_documentModel->indexFromItem(categoryItem).row()));
 
     doItemsLayout();
 }
 
 void KDevDocumentView::updateCategoryItem( KDevCategoryItem *item )
 {
     QString text = KDevelop::ICore::self()->projectController()->prettyFilePath(item->url(), KDevelop::IProjectController::FormatPlain);
     // remove trailing slash
     if (text.length() > 1) {
         text.chop(1);
     }
     item->setText(text);
 }
 
 void KDevDocumentView::updateProjectPaths()
 {
     foreach ( KDevCategoryItem *it, m_documentModel->categoryList() )
         updateCategoryItem( it );
 }
 
 void KDevDocumentView::contentChanged( KDevelop::IDocument* )
 {
 }
 
 void KDevDocumentView::stateChanged( KDevelop::IDocument* document )
 {
     KDevDocumentItem * documentItem = m_doc2index[ document ];
 
     if ( documentItem && documentItem->documentState() != document->state() )
         documentItem->setDocumentState( document->state() );
 
     doItemsLayout();
 }
 
 void KDevDocumentView::documentUrlChanged( KDevelop::IDocument* document )
 {
     closed(document);
     opened(document);
 }
 
 void KDevDocumentView::drawBranches(QPainter* painter, const QRect& rect, const QModelIndex& index) const
 {
-    const bool colorizeByProject = KSharedConfig::openConfig()->group("UiSettings").readEntry("ColorizeByProject", false);
-    if (colorizeByProject) {
+    if (WidgetColorizer::colorizeByProject()) {
         const auto url = index.data(KDevDocumentItem::UrlRole).value<QUrl>();
         const auto project = ICore::self()->projectController()->findProjectForUrl(url);
         if (project) {
-            const auto projectPath = project->path();
-            const QColor color = WidgetColorizer::colorForId(qHash(projectPath), palette());
+            const QColor color = WidgetColorizer::colorForId(qHash(project->path()), palette());
             WidgetColorizer::drawBranches(this, painter, rect, index, color);
         }
     }
 
     QTreeView::drawBranches(painter, rect, index);
 }
diff --git a/plugins/projectmanagerview/projecttreeview.cpp b/plugins/projectmanagerview/projecttreeview.cpp
index 653a69e7dd..829c5bb803 100644
--- a/plugins/projectmanagerview/projecttreeview.cpp
+++ b/plugins/projectmanagerview/projecttreeview.cpp
@@ -1,460 +1,459 @@
 /* This file is part of KDevelop
     Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2009 Aleix Pol <aleixpol@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "projecttreeview.h"
 
 
 #include <QAction>
 #include <QAbstractProxyModel>
 #include <QApplication>
 #include <QHeaderView>
 #include <QMenu>
 #include <QMouseEvent>
 #include <QPainter>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include <project/projectmodel.h>
 #include <language/duchain/duchainutils.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/context.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/iselectioncontroller.h>
 #include <interfaces/isession.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 
 #include "projectmanagerviewplugin.h"
 #include "projectmodelsaver.h"
 #include "projectmodelitemdelegate.h"
 #include "debug.h"
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/util/navigationtooltip.h>
 #include <project/projectutils.h>
 #include <widgetcolorizer.h>
 
 using namespace KDevelop;
 
 namespace {
 const char settingsConfigGroup[] = "ProjectTreeView";
 
 QList<ProjectFileItem*> fileItemsWithin(const QList<ProjectBaseItem*>& items)
 {
     QList<ProjectFileItem*> fileItems;
     fileItems.reserve(items.size());
     foreach(ProjectBaseItem* item, items)
     {
         if (ProjectFileItem *file = item->file())
             fileItems.append(file);
         else if (item->folder())
             fileItems.append(fileItemsWithin(item->children()));
     }
     return fileItems;
 }
 
 QList<ProjectBaseItem*> topLevelItemsWithin(QList<ProjectBaseItem*> items)
 {
     std::sort(items.begin(), items.end(), ProjectBaseItem::pathLessThan);
     Path lastFolder;
     for (int i = items.size() - 1; i >= 0; --i)
     {
         if (lastFolder.isParentOf(items[i]->path()))
             items.removeAt(i);
         else if (items[i]->folder())
             lastFolder = items[i]->path();
     }
     return items;
 }
 
 template<class T>
 void filterDroppedItems(QList<T*> &items, ProjectBaseItem* dest)
 {
     for (int i = items.size() - 1; i >= 0; --i)
     {
         //No drag and drop from and to same location
         if (items[i]->parent() == dest)
             items.removeAt(i);
         //No moving between projects (technically feasible if the projectmanager is the same though...)
         else if (items[i]->project() != dest->project())
             items.removeAt(i);
     }
 }
 
 //TODO test whether this could be replaced by projectbuildsetwidget.cpp::showContextMenu_appendActions
 void popupContextMenu_appendActions(QMenu& menu, const QList<QAction*>& actions)
 {
     menu.addActions(actions);
     menu.addSeparator();
 }
 
 }
 
 ProjectTreeView::ProjectTreeView( QWidget *parent )
         : QTreeView( parent ), m_ctxProject( 0 )
 {
     header()->hide();
 
     setEditTriggers( QAbstractItemView::EditKeyPressed );
 
     setContextMenuPolicy( Qt::CustomContextMenu );
     setSelectionMode( QAbstractItemView::ExtendedSelection );
 
     setIndentation(10);
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::InternalMove);
     setAutoScroll(true);
     setAutoExpandDelay(300);
     setItemDelegate(new ProjectModelItemDelegate(this));
 
     connect( this, &ProjectTreeView::customContextMenuRequested, this, &ProjectTreeView::popupContextMenu );
     connect( this, &ProjectTreeView::activated, this, &ProjectTreeView::slotActivated );
 
     connect( ICore::self(), &ICore::aboutToShutdown,
              this, &ProjectTreeView::aboutToShutdown);
     connect( ICore::self()->projectController(), &IProjectController::projectOpened,
              this, &ProjectTreeView::restoreState );
     connect( ICore::self()->projectController(), &IProjectController::projectClosing,
              this, &ProjectTreeView::saveState );
 
     restoreState();
 }
 
 ProjectTreeView::~ProjectTreeView()
 {
 }
 
 ProjectBaseItem* ProjectTreeView::itemAtPos(QPoint pos)
 {
     return indexAt(pos).data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>();
 }
 
 void ProjectTreeView::dropEvent(QDropEvent* event)
 {
     ProjectItemContext* selectionCtxt =
             static_cast<ProjectItemContext*>(KDevelop::ICore::self()->selectionController()->currentSelection());
     ProjectBaseItem* destItem = itemAtPos(event->pos());
     if (destItem && (dropIndicatorPosition() == AboveItem || dropIndicatorPosition() == BelowItem))
             destItem = destItem->parent();
     if (selectionCtxt && destItem)
     {
         if (ProjectFolderItem *folder = destItem->folder())
         {
             QMenu dropMenu(this);
 
             QString seq = QKeySequence( Qt::ShiftModifier ).toString();
             seq.chop(1); // chop superfluous '+'
             QAction* move = new QAction(i18n( "&Move Here" ) + '\t' + seq, &dropMenu);
             move->setIcon(QIcon::fromTheme(QStringLiteral("go-jump")));
             dropMenu.addAction(move);
 
             seq = QKeySequence( Qt::ControlModifier ).toString();
             seq.chop(1);
             QAction* copy = new QAction(i18n( "&Copy Here" ) + '\t' + seq, &dropMenu);
             copy->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
             dropMenu.addAction(copy);
 
             dropMenu.addSeparator();
 
             QAction* cancel = new QAction(i18n( "C&ancel" ) + '\t' + QKeySequence( Qt::Key_Escape ).toString(), &dropMenu);
             cancel->setIcon(QIcon::fromTheme(QStringLiteral("process-stop")));
             dropMenu.addAction(cancel);
 
             QAction *executedAction = 0;
 
             Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
             if (modifiers == Qt::ControlModifier) {
                 executedAction = copy;
             } else if (modifiers == Qt::ShiftModifier) {
                 executedAction = move;
             } else {
                 executedAction = dropMenu.exec(this->mapToGlobal(event->pos()));
             }
 
             QList<ProjectBaseItem*> usefulItems = topLevelItemsWithin(selectionCtxt->items());
             filterDroppedItems(usefulItems, destItem);
             Path::List paths;
             foreach (ProjectBaseItem* i, usefulItems) {
                 paths << i->path();
             }
             bool success = false;
             if (executedAction == copy) {
                 success = destItem->project()->projectFileManager()->copyFilesAndFolders(paths, folder);
             } else if (executedAction == move) {
                 success = destItem->project()->projectFileManager()->moveFilesAndFolders(usefulItems, folder);
             }
 
             if (success) {
                 //expand target folder
                 expand( mapFromItem(folder));
 
                 //and select new items
                 QItemSelection selection;
                 foreach (const Path &path, paths) {
                     const Path targetPath(folder->path(), path.lastPathSegment());
                     foreach (ProjectBaseItem *item, folder->children()) {
                         if (item->path() == targetPath) {
                             QModelIndex indx = mapFromItem( item );
                             selection.append(QItemSelectionRange(indx, indx));
                             setCurrentIndex(indx);
                         }
                     }
                 }
                 selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
             }
         }
         else if (destItem->target() && destItem->project()->buildSystemManager())
         {
             QMenu dropMenu(this);
 
             QString seq = QKeySequence( Qt::ControlModifier ).toString();
             seq.chop(1);
             QAction* addToTarget = new QAction(i18n( "&Add to Target" ) + '\t' + seq, &dropMenu);
             addToTarget->setIcon(QIcon::fromTheme(QStringLiteral("edit-link")));
             dropMenu.addAction(addToTarget);
 
             dropMenu.addSeparator();
 
             QAction* cancel = new QAction(i18n( "C&ancel" ) + '\t' + QKeySequence( Qt::Key_Escape ).toString(), &dropMenu);
             cancel->setIcon(QIcon::fromTheme(QStringLiteral("process-stop")));
             dropMenu.addAction(cancel);
 
             QAction *executedAction = 0;
 
             Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
             if (modifiers == Qt::ControlModifier) {
                 executedAction = addToTarget;
             } else {
                 executedAction = dropMenu.exec(this->mapToGlobal(event->pos()));
             }
             if (executedAction == addToTarget) {
                 QList<ProjectFileItem*> usefulItems = fileItemsWithin(selectionCtxt->items());
                 filterDroppedItems(usefulItems, destItem);
                 destItem->project()->buildSystemManager()->addFilesToTarget(usefulItems, destItem->target());
             }
         }
     }
     event->accept();
 }
 
 QModelIndex ProjectTreeView::mapFromSource(const QAbstractProxyModel* proxy, const QModelIndex& sourceIdx)
 {
     const QAbstractItemModel* next = proxy->sourceModel();
     Q_ASSERT(next == sourceIdx.model() || qobject_cast<const QAbstractProxyModel*>(next));
     if(next == sourceIdx.model())
         return proxy->mapFromSource(sourceIdx);
     else {
         const QAbstractProxyModel* nextProxy = qobject_cast<const QAbstractProxyModel*>(next);
         QModelIndex idx = mapFromSource(nextProxy, sourceIdx);
         Q_ASSERT(idx.model() == nextProxy);
         return proxy->mapFromSource(idx);
     }
 }
 
 QModelIndex ProjectTreeView::mapFromItem(const ProjectBaseItem* item)
 {
     QModelIndex ret = mapFromSource(qobject_cast<const QAbstractProxyModel*>(model()), item->index());
     Q_ASSERT(ret.model() == model());
     return ret;
 }
 
 void ProjectTreeView::slotActivated( const QModelIndex &index )
 {
     if ( QApplication::keyboardModifiers() & Qt::CTRL || QApplication::keyboardModifiers() & Qt::SHIFT ) {
         // Do not open file when Ctrl or Shift is pressed; that's for selection
         return;
     }
     KDevelop::ProjectBaseItem *item = index.data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>();
     if ( item && item->file() )
     {
         emit activate( item->file()->path() );
     }
 }
 
 void ProjectTreeView::popupContextMenu( const QPoint &pos )
 {
     QList<KDevelop::ProjectBaseItem*> itemlist;
 
     if ( indexAt(pos).isValid() )
     {
         QModelIndexList indexes = selectionModel()->selectedRows();
         foreach( const QModelIndex& index, indexes )
         {
             if ( KDevelop::ProjectBaseItem *item = index.data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>() )
                 itemlist << item;
         }
     }
 
     if( !itemlist.isEmpty() )
     {
         m_ctxProject = itemlist.at(0)->project();
     } else
     {
         m_ctxProject = 0;
     }
 
     QMenu menu( this );
 
     KDevelop::ProjectItemContextImpl context(itemlist);
     QList<ContextMenuExtension> extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions( &context );
 
     QList<QAction*> buildActions;
     QList<QAction*> vcsActions;
     QList<QAction*> extActions;
     QList<QAction*> projectActions;
     QList<QAction*> fileActions;
     QList<QAction*> runActions;
     foreach( const ContextMenuExtension& ext, extensions )
     {
         buildActions += ext.actions(ContextMenuExtension::BuildGroup);
         fileActions += ext.actions(ContextMenuExtension::FileGroup);
         projectActions += ext.actions(ContextMenuExtension::ProjectGroup);
         vcsActions += ext.actions(ContextMenuExtension::VcsGroup);
         extActions += ext.actions(ContextMenuExtension::ExtensionGroup);
         runActions += ext.actions(ContextMenuExtension::RunGroup);
     }
 
     popupContextMenu_appendActions(menu, buildActions);
     popupContextMenu_appendActions(menu, runActions );
     popupContextMenu_appendActions(menu, fileActions);
     popupContextMenu_appendActions(menu, vcsActions);
     popupContextMenu_appendActions(menu, extActions);
 
     if ( !itemlist.isEmpty() && itemlist.size() == 1 && itemlist[0]->folder() && !itemlist[0]->folder()->parent() )
     {
         QAction* projectConfig = new QAction(i18n("Open Configuration..."), this);
         projectConfig->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
         connect( projectConfig, &QAction::triggered, this, &ProjectTreeView::openProjectConfig );
         projectActions << projectConfig;
     }
     popupContextMenu_appendActions(menu, projectActions);
 
     if(!itemlist.isEmpty())
         KDevelop::populateParentItemsMenu(itemlist.front(), &menu);
 
     if ( !menu.isEmpty() ) {
         menu.exec( mapToGlobal( pos ) );
     }
 }
 
 void ProjectTreeView::openProjectConfig()
 {
     if( m_ctxProject )
     {
         IProjectController* ip = ICore::self()->projectController();
         ip->configureProject( m_ctxProject );
     }
 }
 
 void ProjectTreeView::saveState()
 {
     KConfigGroup configGroup( ICore::self()->activeSession()->config(), settingsConfigGroup );
 
     ProjectModelSaver saver;
     saver.setView( this );
     saver.saveState( configGroup );
 }
 
 void ProjectTreeView::restoreState(IProject* project)
 {
     KConfigGroup configGroup( ICore::self()->activeSession()->config(), settingsConfigGroup );
 
     ProjectModelSaver saver;
     saver.setProject( project );
     saver.setView( this );
     saver.restoreState( configGroup );
 }
 
 void ProjectTreeView::aboutToShutdown()
 {
     // save all projects, not just the last one that is closed
     disconnect( ICore::self()->projectController(), &IProjectController::projectClosing,
                 this, &ProjectTreeView::saveState );
     saveState();
 }
 
 bool ProjectTreeView::event(QEvent* event)
 {
     if(event->type()==QEvent::ToolTip)
     {
         QPoint p = mapFromGlobal(QCursor::pos());
         QModelIndex idxView = indexAt(p);
 
         ProjectBaseItem* it = idxView.data(ProjectModel::ProjectItemRole).value<ProjectBaseItem*>();
         QModelIndex idx;
         if(it)
             idx = it->index();
 
         if((m_idx!=idx || !m_tooltip) && it && it->file())
         {
             m_idx=idx;
             ProjectFileItem* file=it->file();
             KDevelop::DUChainReadLocker lock(KDevelop::DUChain::lock());
             TopDUContext* top= DUChainUtils::standardContextForUrl(file->path().toUrl());
 
             if(m_tooltip)
                 m_tooltip->close();
 
             if(top)
             {
                 QWidget* navigationWidget = top->createNavigationWidget();
                 if( navigationWidget )
                 {
                     m_tooltip = new KDevelop::NavigationToolTip(this, mapToGlobal(p) + QPoint(40, 0), navigationWidget);
                     m_tooltip->resize( navigationWidget->sizeHint() + QSize(10, 10) );
                     qCDebug(PLUGIN_PROJECTMANAGERVIEW) << "tooltip size" << m_tooltip->size();
                     ActiveToolTip::showToolTip(m_tooltip);
                     return true;
                 }
             }
         }
     }
 
     return QAbstractItemView::event(event);
 }
 
 void ProjectTreeView::keyPressEvent(QKeyEvent* event)
 {
     if (event->key() == Qt::Key_Return && currentIndex().isValid() && state()!=QAbstractItemView::EditingState)
     {
         event->accept();
         slotActivated(currentIndex());
     }
     else
         QTreeView::keyPressEvent(event);
 }
 
 void ProjectTreeView::drawBranches(QPainter* painter, const QRect& rect, const QModelIndex& index) const
 {
-    const bool colorizeByProject = KSharedConfig::openConfig()->group("UiSettings").readEntry("ColorizeByProject", false);
-    if (colorizeByProject) {
+    if (WidgetColorizer::colorizeByProject()) {
         const auto projectPath = index.data(ProjectModel::ProjectRole).value<IProject *>()->path();
         const QColor color = WidgetColorizer::colorForId(qHash(projectPath), palette());
         WidgetColorizer::drawBranches(this, painter, rect, index, color);
     }
 
     QTreeView::drawBranches(painter, rect, index);
 }
diff --git a/util/widgetcolorizer.cpp b/util/widgetcolorizer.cpp
index bb1e280c86..93111b67c4 100644
--- a/util/widgetcolorizer.cpp
+++ b/util/widgetcolorizer.cpp
@@ -1,62 +1,69 @@
 /*
  * Copyright 2015  Kevin Funk <kfunk@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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "widgetcolorizer.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iuicontroller.h>
 
 #include <KColorScheme>
+#include <KSharedConfig>
+#include <KConfigGroup>
 
 #include <QColor>
 #include <QPainter>
 #include <QPalette>
 #include <QTreeView>
 
 using namespace KDevelop;
 
 void WidgetColorizer::drawBranches(const QTreeView* treeView, QPainter* painter,
                                               const QRect& rect, const QModelIndex& index, const QColor& baseColor)
 {
     // We want this color to be a bit transparent:
     QColor color(baseColor);
     color.setAlpha(!index.parent().isValid() ? 50 : 110);
 
     QRect newRect(rect);
     newRect.setWidth(treeView->indentation());
     painter->fillRect(newRect, color);
 }
 
 QColor WidgetColorizer::colorForId(uint id, const QPalette& activePalette)
 {
     const QColor schemeColor = activePalette.foreground().color();
     int lightness = (schemeColor.blue() + schemeColor.red() + schemeColor.green()) / 3;
     int high = 255;
     int low = 100;
 
     // Assign a brighter color if the scheme color is dark.
     if (lightness > 100) {
         low += 85;
         return QColor(qAbs((id % (high-low)) + low), qAbs(((id / 50 ) % (high-low)) + low), qAbs(((id / (50 * 50)) % (high-low)) + low));
     }
 
     return QColor(qAbs(id % (high-low)), qAbs((id / 50 ) % (high-low)), qAbs((id / (50 * 50)) % (high-low)));
 }
+
+bool WidgetColorizer::colorizeByProject()
+{
+    return KSharedConfig::openConfig()->group("UiSettings").readEntry("ColorizeByProject", false);
+}
diff --git a/util/widgetcolorizer.h b/util/widgetcolorizer.h
index 4df8445c59..9dba7d1df9 100644
--- a/util/widgetcolorizer.h
+++ b/util/widgetcolorizer.h
@@ -1,46 +1,52 @@
 /*
  * Copyright 2015  Kevin Funk <kfunk@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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #pragma once
 
 #include <util/utilexport.h>
 
 #include <QtGlobal>
 
 class QColor;
 class QModelIndex;
 class QPainter;
 class QRect;
 class QPalette;
 class QString;
 class QTreeView;
 
 namespace KDevelop {
 
 namespace WidgetColorizer
 {
     KDEVPLATFORMUTIL_EXPORT void drawBranches(const QTreeView* treeView, QPainter* painter,
                                               const QRect& rect, const QModelIndex& index, const QColor& color);
 
     KDEVPLATFORMUTIL_EXPORT QColor colorForId(uint id, const QPalette& activePalette);
+
+    /**
+     * Returns true when the setting is enabled to colorize widgets representing
+     * files belonging to projects.
+     */
+    KDEVPLATFORMUTIL_EXPORT bool colorizeByProject();
 };
 
 }