diff --git a/language/duchain/navigation/abstractnavigationwidget.cpp b/language/duchain/navigation/abstractnavigationwidget.cpp
index 72ea54bd5b..d7d241ac28 100644
--- a/language/duchain/navigation/abstractnavigationwidget.cpp
+++ b/language/duchain/navigation/abstractnavigationwidget.cpp
@@ -1,293 +1,293 @@
 /*
    Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 
 #include "abstractnavigationwidget.h"
 
 #include <QtCore/QMap>
 #include <QtCore/QMetaObject>
 #include <QScrollBar>
 #include <QBoxLayout>
 
 #include <KLocalizedString>
 #include <ktextbrowser.h>
 
 #include "../declaration.h"
 #include "../ducontext.h"
 #include "../duchain.h"
 #include "../duchainlock.h"
 #include "util/debug.h"
 #include <qapplication.h>
 #include <qevent.h>
 
 namespace KDevelop {
 
 AbstractNavigationWidget::AbstractNavigationWidget()
   : m_browser(0), m_currentWidget(0)
 {
   setPalette( QApplication::palette() );
   setFocusPolicy(Qt::NoFocus);
   resize(100, 100);
 }
 
 const int maxNavigationWidgetWidth = 580;
 
 QSize AbstractNavigationWidget::sizeHint() const
 {
   if(m_browser) {
     updateIdealSize();
     QSize ret = QSize(qMin(m_idealTextSize.width(), maxNavigationWidgetWidth), qMin(m_idealTextSize.height(), 300));
     if(m_idealTextSize.height()>=300) { //make space for the scrollbar in case it's not fitting
       ret.rwidth() += 17; //m_browser->verticalScrollBar()->width() returns 100, for some reason
     }
 
     if(m_currentWidget) {
       ret.setHeight( ret.height() + m_currentWidget->sizeHint().height() );
       if(m_currentWidget->sizeHint().width() > ret.width())
         ret.setWidth(m_currentWidget->sizeHint().width());
       if(ret.width() < 500) //When we embed a widget, give it some space, even if it doesn't have a large size-hint
         ret.setWidth(500);
 
     }
     return ret;
   } else
     return QWidget::sizeHint();
 }
 
 void AbstractNavigationWidget::initBrowser(int height) {
   Q_UNUSED(height);
   m_browser = new QTextBrowser;
 
   // since we can embed arbitrary HTML we have to make sure it stays readable by forcing a black-white palette
   QPalette p;
   p.setColor(QPalette::AlternateBase, Qt::white);
   p.setColor(QPalette::Base, Qt::white);
   p.setColor(QPalette::Text, Qt::black);
   m_browser->setPalette( p );
 
   m_browser->setOpenLinks(false);
   m_browser->setOpenExternalLinks(false);
 
   QVBoxLayout* layout = new QVBoxLayout;
   layout->addWidget(m_browser);
   layout->setMargin(0);
   setLayout(layout);
 
   connect( m_browser.data(), &QTextBrowser::anchorClicked, this, &AbstractNavigationWidget::anchorClicked );
 
   foreach(QWidget* w, findChildren<QWidget*>())
     w->setContextMenuPolicy(Qt::NoContextMenu);
 }
 
 AbstractNavigationWidget::~AbstractNavigationWidget() {
   if(m_currentWidget)
     layout()->removeWidget(m_currentWidget);
 
 }
 
 void AbstractNavigationWidget::setContext(NavigationContextPointer context, int initBrows)
 {
   if(m_browser == 0)
     initBrowser(initBrows);
 
   if(!context) {
     qCDebug(LANGUAGE) << "no new context created";
     return;
   }
   if(context == m_context && (!context || context->alreadyComputed()))
     return;
 
   if (!m_startContext)
     m_startContext = m_context;
 
   bool wasInitial = (m_context == m_startContext);
 
   m_context = context;
   update();
 
   emit contextChanged(wasInitial, m_context == m_startContext);
   emit sizeHintChanged();
 }
 
 void AbstractNavigationWidget::updateIdealSize() const {
   if(m_context && !m_idealTextSize.isValid()) {
     QTextDocument doc;
     doc.setHtml(m_currentText);
     if(doc.idealWidth() > maxNavigationWidgetWidth) {
       doc.setPageSize( QSize(maxNavigationWidgetWidth, 30) );
       m_idealTextSize.setWidth(maxNavigationWidgetWidth);
     }else{
       m_idealTextSize.setWidth(doc.idealWidth());
     }
     m_idealTextSize.setHeight(doc.size().height());
   }
 }
 
 void AbstractNavigationWidget::update() {
   setUpdatesEnabled(false);
   Q_ASSERT( m_context );
 
   QString html = m_context->html();
   if(!html.isEmpty()) {
     int scrollPos = m_browser->verticalScrollBar()->value();
 
     m_browser->setHtml( html );
 
     m_currentText = html;
     m_idealTextSize = QSize();
 
     QSize hint = sizeHint();
     if(hint.height() >= m_idealTextSize.height()) {
       m_browser->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     }else{
       m_browser->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     }
 
     m_browser->verticalScrollBar()->setValue(scrollPos);
     m_browser->scrollToAnchor("currentPosition");
     m_browser->show();
   }else{
     m_browser->hide();
   }
 
   if(m_currentWidget) {
     layout()->removeWidget(m_currentWidget);
     m_currentWidget->setParent(0);
   }
 
   m_currentWidget = m_context->widget();
 
   m_browser->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   m_browser->setMaximumHeight(10000);
 
   if(m_currentWidget) {
     if (m_currentWidget->metaObject()
-          ->indexOfSignal(SIGNAL(navigateDeclaration(KDevelop::IndexedDeclaration))) != -1)
+          ->indexOfSignal(QMetaObject::normalizedSignature("navigateDeclaration(KDevelop::IndexedDeclaration)")) != -1)
     {
       connect(m_currentWidget, SIGNAL(navigateDeclaration(KDevelop::IndexedDeclaration)),
               this, SLOT(navigateDeclaration(KDevelop::IndexedDeclaration)));
     }
     layout()->addWidget(m_currentWidget);
     if(m_context->isWidgetMaximized()) {
       //Leave unused room to the widget
       m_browser->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
       m_browser->setMaximumHeight(m_idealTextSize.height());
     }
   }
 
   setUpdatesEnabled(true);
 }
 
 NavigationContextPointer AbstractNavigationWidget::context() {
   return m_context;
 }
 
 void AbstractNavigationWidget::navigateDeclaration(KDevelop::IndexedDeclaration decl) {
   DUChainReadLocker lock( DUChain::lock() );
   setContext(m_context->accept(decl));
 }
 
 void AbstractNavigationWidget::anchorClicked(const QUrl& url) {
   DUChainReadLocker lock( DUChain::lock() );
 
   //We may get deleted while the call to acceptLink, so make sure we don't crash in that case
   QPointer<AbstractNavigationWidget> thisPtr(this);
   NavigationContextPointer oldContext = m_context;
   NavigationContextPointer nextContext = m_context->acceptLink(url.toString());
 
   if(thisPtr)
     setContext( nextContext );
 }
 
 void AbstractNavigationWidget::next() {
   DUChainReadLocker lock( DUChain::lock() );
   Q_ASSERT( m_context );
   m_context->nextLink();
   update();
 }
 
 void AbstractNavigationWidget::previous() {
   DUChainReadLocker lock( DUChain::lock() );
   Q_ASSERT( m_context );
   m_context->previousLink();
   update();
 }
 
 void AbstractNavigationWidget::accept() {
   DUChainReadLocker lock( DUChain::lock() );
   Q_ASSERT( m_context );
 
   QPointer<AbstractNavigationWidget> thisPtr(this);
   NavigationContextPointer oldContext = m_context;
   NavigationContextPointer nextContext = m_context->accept();
 
   if(thisPtr)
     setContext( nextContext );
 }
 
 void AbstractNavigationWidget::back() {
   DUChainReadLocker lock( DUChain::lock() );
 
   QPointer<AbstractNavigationWidget> thisPtr(this);
   NavigationContextPointer oldContext = m_context;
   NavigationContextPointer nextContext = m_context->back();
 
   if(thisPtr)
     setContext( nextContext );
 }
 
 void AbstractNavigationWidget::up() {
   DUChainReadLocker lock( DUChain::lock() );
   m_context->up();
   update();
 }
 
 void AbstractNavigationWidget::down() {
   DUChainReadLocker lock( DUChain::lock() );
   m_context->down();
   update();
 }
 
 void AbstractNavigationWidget::embeddedWidgetAccept() {
   accept();
 }
 void AbstractNavigationWidget::embeddedWidgetDown() {
   down();
 }
 
 void AbstractNavigationWidget::embeddedWidgetRight() {
   next();
 }
 
 void AbstractNavigationWidget::embeddedWidgetLeft() {
   previous();
 }
 
 void AbstractNavigationWidget::embeddedWidgetUp() {
   up();
 }
 
 void AbstractNavigationWidget::wheelEvent(QWheelEvent* event )
 {
     QWidget::wheelEvent(event);
     event->accept();
     return;
 }
 
 }
 
diff --git a/plugins/contextbrowser/contextbrowserview.cpp b/plugins/contextbrowser/contextbrowserview.cpp
index 229d8518cc..b60ea33cd4 100644
--- a/plugins/contextbrowser/contextbrowserview.cpp
+++ b/plugins/contextbrowser/contextbrowserview.cpp
@@ -1,327 +1,327 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "contextbrowserview.h"
 
 ///TODO: cleanup includes
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QShowEvent>
 #include <QAction>
 #include <QMenu>
 #include <QIcon>
 
 #include <QTextBrowser>
 #include <KLocalizedString>
 #include <KComboBox>
 #include <ktexteditor/document.h>
 #include <ktexteditor/view.h>
 
 #include <language/duchain/declaration.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <serialization/indexedstring.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include "contextbrowser.h"
 #include "debug.h"
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/specializationstore.h>
 #include "browsemanager.h"
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <kparts/part.h>
 #include <qapplication.h>
 #include <language/interfaces/codecontext.h>
 #include <language/duchain/navigation/abstractdeclarationnavigationcontext.h>
 #include <language/duchain/navigation/useswidget.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iplugincontroller.h>
 
 using namespace KDevelop;
 
 QWidget* ContextBrowserView::createWidget(KDevelop::DUContext* context) {
         m_context = IndexedDUContext(context);
         if(m_context.data()) {
             return m_context.data()->createNavigationWidget();
         }
         return 0;
 }
 
 KDevelop::IndexedDeclaration ContextBrowserView::declaration() const {
     return m_declaration;
 }
 
 QWidget* ContextBrowserView::createWidget(Declaration* decl, TopDUContext* topContext) {
     m_declaration = IndexedDeclaration(decl);
     return decl->context()->createNavigationWidget(decl, topContext);
 }
 
 
 void ContextBrowserView::resetWidget()
 {
     if (m_navigationWidget) {
         delete m_navigationWidget;
         m_navigationWidget = 0;
     }
 }
 
 void ContextBrowserView::declarationMenu() {
     DUChainReadLocker lock(DUChain::lock());
 
     AbstractNavigationWidget* navigationWidget = dynamic_cast<AbstractNavigationWidget*>(m_navigationWidget.data());
     if(navigationWidget) {
         AbstractDeclarationNavigationContext* navigationContext = dynamic_cast<AbstractDeclarationNavigationContext*>(navigationWidget->context().data());
         if(navigationContext && navigationContext->declaration().data()) {
             KDevelop::DeclarationContext* c = new KDevelop::DeclarationContext(navigationContext->declaration().data());
             lock.unlock();
             QMenu menu;
             QList<ContextMenuExtension> extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions( c );
 
             ContextMenuExtension::populateMenu(&menu, extensions);
             menu.exec(QCursor::pos());
         }
     }
 }
 
 void ContextBrowserView::updateLockIcon(bool checked) {
     m_lockButton->setIcon(QIcon::fromTheme(checked ? "document-encrypt" : "document-decrypt"));
 }
 
 ContextBrowserView::ContextBrowserView( ContextBrowserPlugin* plugin, QWidget* parent ) : QWidget(parent), m_plugin(plugin), m_navigationWidget(new QTextBrowser()), m_autoLocked(false) {
     setWindowIcon( QIcon::fromTheme("applications-development-web") );
 
     m_allowLockedUpdate = false;
 
     m_buttons = new QHBoxLayout;
     m_buttons->addStretch();
     m_declarationMenuButton = new QToolButton();
     m_declarationMenuButton->setIcon(QIcon::fromTheme("code-class"));
     m_declarationMenuButton->setToolTip(i18n("Declaration menu"));
     connect(m_declarationMenuButton, &QToolButton::clicked, this, &ContextBrowserView::declarationMenu);
     m_buttons->addWidget(m_declarationMenuButton);
     m_lockButton = new QToolButton();
     m_lockButton->setCheckable(true);
     m_lockButton->setChecked(false);
     m_lockButton->setToolTip(i18n("Lock current view"));
     updateLockIcon(m_lockButton->isChecked());
     connect(m_lockButton, &QToolButton::toggled, this, &ContextBrowserView::updateLockIcon);
     m_buttons->addWidget(m_lockButton);
 
     m_layout = new QVBoxLayout;
     m_layout->setSpacing(0);
     m_layout->setMargin(0);
     m_layout->addLayout(m_buttons);
     m_layout->addWidget(m_navigationWidget);
     //m_layout->addStretch();
     setLayout(m_layout);
 
     m_plugin->registerToolView(this);
 }
 
 ContextBrowserView::~ContextBrowserView() {
     m_plugin->unRegisterToolView(this);
 }
 
 void ContextBrowserView::focusInEvent(QFocusEvent* event) {
     //Indicate that we have focus
     qCDebug(PLUGIN_CONTEXTBROWSER) << "got focus";
 //     parentWidget()->setBackgroundRole(QPalette::ToolTipBase);
 /*    m_layout->removeItem(m_buttons);*/
 
     return QWidget::focusInEvent(event);
 }
 
 void ContextBrowserView::focusOutEvent(QFocusEvent* event) {
     qCDebug(PLUGIN_CONTEXTBROWSER) << "lost focus";
 //     parentWidget()->setBackgroundRole(QPalette::Background);
 /*    m_layout->insertLayout(0, m_buttons);
     for(int a = 0; a < m_buttons->count(); ++a) {
         QWidgetItem* item = dynamic_cast<QWidgetItem*>(m_buttons->itemAt(a));
     }*/
     QWidget::focusOutEvent(event);
 }
 
 bool ContextBrowserView::event(QEvent* event) {
     QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(event);
 
     if(hasFocus() && keyEvent) {
         AbstractNavigationWidget* navigationWidget = dynamic_cast<AbstractNavigationWidget*>(m_navigationWidget.data());
         if(navigationWidget && event->type() == QEvent::KeyPress) {
             int key = keyEvent->key();
             if(key == Qt::Key_Left)
                 navigationWidget->previous();
             if(key == Qt::Key_Right)
                 navigationWidget->next();
             if(key == Qt::Key_Up)
                 navigationWidget->up();
             if(key == Qt::Key_Down)
                 navigationWidget->down();
             if(key == Qt::Key_Return || key == Qt::Key_Enter)
                 navigationWidget->accept();
 
 
             if(key == Qt::Key_L)
                 m_lockButton->toggle();
         }
     }
     return QWidget::event(event);
 }
 
 void ContextBrowserView::showEvent(QShowEvent* event) {
     DUChainReadLocker lock(DUChain::lock());
     TopDUContext* top = m_lastUsedTopContext.data();
     if(top && m_navigationWidgetDeclaration.isValid() && m_navigationWidgetDeclaration.getDeclaration(top)) {
         if(top) {
             //Update the navigation-widget
             Declaration* decl = m_navigationWidgetDeclaration.getDeclaration(top);
             setDeclaration(decl, top, true);
             //Update the declaration combo-box
             /*
             TODO: bring this back if required
             DUContext* context = 0;
             KDevelop::IDocument* doc = ICore::self()->documentController()->activeDocument();
             if(doc && doc->textDocument() && doc->textDocument()->activeView()) {
                 KTextEditor::Cursor c = doc->textDocument()->activeView()->cursorPosition();
                 context = getContextAt(top->url().toUrl(), c);
             }
             m_plugin->updateDeclarationListBox(context);
             */
         }
     }
     QWidget::showEvent(event);
 }
 
 bool ContextBrowserView::isLocked() const {
     bool isLocked;
     if (m_allowLockedUpdate) {
         isLocked = false;
     } else {
         isLocked = m_lockButton->isChecked();
     }
     return isLocked;
 }
 
 void ContextBrowserView::updateMainWidget(QWidget* widget)
 {
     if (widget) {
         setUpdatesEnabled(false);
         qCDebug(PLUGIN_CONTEXTBROWSER) << "";
         resetWidget();
         m_navigationWidget = widget;
         m_layout->insertWidget(1, widget, 1);
         m_allowLockedUpdate = false;
         setUpdatesEnabled(true);
-        if (widget->metaObject()->indexOfSignal(SIGNAL(contextChanged(bool,bool))) != -1) {
+        if (widget->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("contextChanged(bool,bool)")) != -1) {
             connect(widget, SIGNAL(contextChanged(bool,bool)), this, SLOT(navigationContextChanged(bool,bool)));
         }
     }
 }
 
 void ContextBrowserView::navigationContextChanged(bool wasInitial, bool isInitial)
 {
     if(wasInitial && !isInitial && !m_lockButton->isChecked())
     {
         m_autoLocked = true;
         m_lockButton->setChecked(true);
     }else if(!wasInitial && isInitial && m_autoLocked)
     {
         m_autoLocked = false;
         m_lockButton->setChecked(false);
     }else if(isInitial) {
         m_autoLocked = false;
     }
 }
 
 void ContextBrowserView::setDeclaration(KDevelop::Declaration* decl, KDevelop::TopDUContext* topContext, bool force) {
     m_lastUsedTopContext = IndexedTopDUContext(topContext);
 
     if(isLocked() && (!m_navigationWidget.data() || !isVisible()))
     {
         // Automatically remove the locked state if the view is not visible or the widget was deleted,
         // because the locked state has side-effects on other navigation functionality.
         m_autoLocked = false;
         m_lockButton->setChecked(false);
     }
 
     if(m_navigationWidgetDeclaration == decl->id() && !force)
         return;
 
     m_navigationWidgetDeclaration = decl->id();
 
     if (!isLocked() && (isVisible() || force)) {  // NO-OP if toolview is hidden, for performance reasons
 
         QWidget* w = createWidget(decl, topContext);
         updateMainWidget(w);
     }
 }
 
 KDevelop::IndexedDeclaration ContextBrowserView::lockedDeclaration() const {
     if(m_lockButton->isChecked())
         return declaration();
     else
         return KDevelop::IndexedDeclaration();
 }
 
 void ContextBrowserView::allowLockedUpdate() {
     m_allowLockedUpdate = true;
 }
 
 void ContextBrowserView::setNavigationWidget(QWidget* widget) {
     updateMainWidget(widget);
 }
 
 void ContextBrowserView::setContext(KDevelop::DUContext* context) {
     if(!context)
         return;
 
     m_lastUsedTopContext = IndexedTopDUContext(context->topContext());
 
     if(context->owner()) {
         if(context->owner()->id() == m_navigationWidgetDeclaration)
             return;
         m_navigationWidgetDeclaration = context->owner()->id();
     }else{
         m_navigationWidgetDeclaration = DeclarationId();
     }
 
     if (!isLocked() && isVisible()) { // NO-OP if toolview is hidden, for performance reasons
 
         QWidget* w = createWidget(context);
         updateMainWidget(w);
     }
 }
 
 void ContextBrowserView::setSpecialNavigationWidget(QWidget* widget) {
     if (!isLocked() && isVisible()) {
         Q_ASSERT(widget);
         updateMainWidget(widget);
     } else if(widget) {
         widget->deleteLater();
     }
 }
 
diff --git a/shell/statusbar.cpp b/shell/statusbar.cpp
index b292983560..43642f487f 100644
--- a/shell/statusbar.cpp
+++ b/shell/statusbar.cpp
@@ -1,257 +1,257 @@
 /* This file is part of the KDE project
    Copyright 2007 Hamish Rodda <rodda@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "statusbar.h"
 #include "progresswidget/statusbarprogresswidget.h"
 #include "progresswidget/progressmanager.h"
 #include "progresswidget/progressdialog.h"
 
 #include <QtCore/QTimer>
 #include <QProgressBar>
 #include <QLabel>
 #include <QtCore/QSignalMapper>
 
 #include <KColorScheme>
 #include <KSqueezedTextLabel>
 
 #include <interfaces/istatus.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <sublime/view.h>
 
 #include "plugincontroller.h"
 #include "core.h"
 
 namespace KDevelop
 {
 
 StatusBar::StatusBar(QWidget* parent)
     : QStatusBar(parent)
     , m_timer(new QTimer(this))
     , m_currentView(0)
     , m_errorRemovalMapper(new QSignalMapper(this))
 {
     m_timer->setSingleShot(true);
     connect(m_timer, &QTimer::timeout, this, &StatusBar::slotTimeout);
     connect(Core::self()->pluginController(), &IPluginController::pluginLoaded, this, &StatusBar::pluginLoaded);
 
     foreach (IPlugin* plugin, Core::self()->pluginControllerInternal()->allPluginsForExtension("IStatus"))
         registerStatus(plugin);
 
     registerStatus(Core::self()->languageController()->backgroundParser());
 
     connect(m_errorRemovalMapper, static_cast<void(QSignalMapper::*)(QWidget*)>(&QSignalMapper::mapped), this, &StatusBar::removeError);
 
     m_progressController = Core::self()->progressController();
     m_progressDialog = new ProgressDialog(this, parent); // construct this first, then progressWidget
     m_progressDialog->setVisible(false);
     m_progressWidget = new StatusbarProgressWidget(m_progressDialog, this);
 
     addPermanentWidget(m_progressWidget, 0);
 }
 
 void StatusBar::removeError(QWidget* w)
 {
     removeWidget(w);
     w->deleteLater();
 }
 
 void StatusBar::viewChanged(Sublime::View* view)
 {
     if (m_currentView)
         m_currentView->disconnect(this);
 
     m_currentView = view;
 
     if (view) {
         connect(view, &Sublime::View::statusChanged, this, &StatusBar::viewStatusChanged);
         QStatusBar::showMessage(view->viewStatus(), 0);
 
     }
 }
 
 void StatusBar::viewStatusChanged(Sublime::View* view)
 {
     QStatusBar::showMessage(view->viewStatus(), 0);
 }
 
 void StatusBar::pluginLoaded(IPlugin* plugin)
 {
     if (qobject_cast<IStatus*>(plugin))
         registerStatus(plugin);
 }
 
 void StatusBar::registerStatus(QObject* status)
 {
     Q_ASSERT(qobject_cast<IStatus*>(status));
     // can't convert this to new signal slot syntax, IStatus is not a QObject
     connect(status, SIGNAL(clearMessage(KDevelop::IStatus*)),
             SLOT(clearMessage(KDevelop::IStatus*)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(showMessage(KDevelop::IStatus*,QString,int)),
             SLOT(showMessage(KDevelop::IStatus*,QString,int)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(hideProgress(KDevelop::IStatus*)),
             SLOT(hideProgress(KDevelop::IStatus*)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(showProgress(KDevelop::IStatus*,int,int,int)),
             SLOT(showProgress(KDevelop::IStatus*,int,int,int)),
             Qt::QueuedConnection);
 
     // Don't try to connect when the status object doesn't provide an error message signal (ie. avoid warning)
-    if (status->metaObject()->indexOfSignal(SIGNAL(showErrorMessage(QString,int))) != -1) {
+    if (status->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("showErrorMessage(QString,int)")) != -1) {
         connect(status, SIGNAL(showErrorMessage(QString,int)),
                 SLOT(showErrorMessage(QString,int)), Qt::QueuedConnection);
     }
 }
 
 QWidget* errorMessage(QWidget* parent, const QString& text)
 {
     KSqueezedTextLabel* label = new KSqueezedTextLabel(parent);
     KStatefulBrush red(KColorScheme::Window, KColorScheme::NegativeText);
     QPalette pal = label->palette();
     pal.setBrush(QPalette::WindowText, red.brush(label));
     label->setPalette(pal);
     label->setAlignment(Qt::AlignRight);
     label->setText(text);
     label->setToolTip(text);
     return label;
 }
 
 QTimer* StatusBar::errorTimeout(QWidget* error, int timeout)
 {
     QTimer* timer = new QTimer(error);
     timer->setSingleShot(true);
     timer->setInterval(1000*timeout);
     m_errorRemovalMapper->setMapping(timer, error);
     connect(timer, &QTimer::timeout, m_errorRemovalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
     return timer;
 }
 
 void StatusBar::showErrorMessage(const QString& message, int timeout)
 {
     QWidget* error = errorMessage(this, message);
     QTimer* timer = errorTimeout(error, timeout);
     addWidget(error);
     timer->start(); // triggers removeError()
 }
 
 void StatusBar::slotTimeout()
 {
     QMutableMapIterator<IStatus*, Message> it = m_messages;
 
     while (it.hasNext()) {
         it.next();
         if (it.value().timeout) {
             it.value().timeout -= m_timer->interval();
             if (it.value().timeout == 0)
                 it.remove();
         }
     }
 
     updateMessage();
 }
 
 void StatusBar::updateMessage()
 {
     if (m_timer->isActive()) {
         m_timer->stop();
         m_timer->setInterval(m_time.elapsed());
         slotTimeout();
     }
 
     QString ret;
     int timeout = 0;
 
     foreach (const Message& m, m_messages) {
         if (!ret.isEmpty())
             ret += "; ";
 
         ret += m.text;
 
         if (timeout)
             timeout = qMin(timeout, m.timeout);
         else
             timeout = m.timeout;
     }
 
     if (!ret.isEmpty())
         QStatusBar::showMessage(ret);
     else
         QStatusBar::clearMessage();
 
     if (timeout) {
         m_time.start();
         m_timer->start(timeout);
     }
 }
 
 void StatusBar::clearMessage( IStatus* status )
 {
     if (m_messages.contains(status)) {
         m_messages.remove(status);
         updateMessage();
     }
 }
 
 void StatusBar::showMessage( IStatus* status, const QString & message, int timeout)
 {
     if ( m_progressItems.contains(status) ) {
         ProgressItem* i = m_progressItems[status];
         i->setStatus(message);
     } else {
         Message m;
         m.text = message;
         m.timeout = timeout;
         m_messages.insert(status, m);
         updateMessage();
     }
 }
 
 void StatusBar::hideProgress( IStatus* status )
 {
    if (m_progressItems.contains(status)) {
         m_progressItems[status]->setComplete();
         m_progressItems.remove(status);
    }
 
 }
 
 void StatusBar::showProgress( IStatus* status, int minimum, int maximum, int value)
 {
     if (!m_progressItems.contains(status)) {
         bool canBeCanceled = false;
         m_progressItems[status] = m_progressController->createProgressItem(
             ProgressManager::getUniqueID(), status->statusName(), QString(), canBeCanceled);;
     }
     
     ProgressItem* i = m_progressItems[status];
     m_progressWidget->raise();
     m_progressDialog->raise();
     if( minimum == 0 && maximum == 0 ) {
         i->setUsesBusyIndicator( true );
     } else {
         i->setUsesBusyIndicator( false );
         i->setProgress( 100*value/maximum );
     }
 }
 
 }