diff --git a/kdevplatform/language/classmodel/classmodelnode.h b/kdevplatform/language/classmodel/classmodelnode.h
index 9c46c06b6e..e4d79d23e5 100644
--- a/kdevplatform/language/classmodel/classmodelnode.h
+++ b/kdevplatform/language/classmodel/classmodelnode.h
@@ -1,331 +1,333 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2007-2009 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_CLASSMODELNODE_H
 #define KDEVPLATFORM_CLASSMODELNODE_H
 
 #include "classmodel.h"
-#include <qicon.h>
+
 #include "../duchain/identifier.h"
 #include "../duchain/duchainpointer.h"
 #include "classmodelnodescontroller.h"
 
+#include <QIcon>
+
 class NodesModelInterface;
 
 namespace KDevelop
 {
   class ClassDeclaration;
   class ClassFunctionDeclaration;
   class ClassMemberDeclaration;
   class Declaration;
 }
 
 namespace ClassModelNodes
 {
 
 /// Base node class - provides basic functionality.
 class Node
 {
 public:
   Node(const QString& a_displayName, NodesModelInterface* a_model);
   virtual ~Node();
 
 public: // Operations
   /// Clear all the children from the node.
   void clear();
 
   /// Called by the model to collapse the node and remove sub-items if needed.
   virtual void collapse() {};
 
   /// Called by the model to expand the node and populate it with sub-nodes if needed.
   virtual void expand() {};
 
   /// Append a new child node to the list.
   void addNode(Node* a_child);
 
   /// Remove child node from the list and delete it.
   void removeNode(Node* a_child);
 
   /// Remove this node and delete it.
   void removeSelf() { m_parentNode->removeNode(this); }
 
   /// Called once the node has been populated to sort the entire tree / branch.
   void recursiveSort();
 
 public: // Info retrieval
   /// Return the parent associated with this node.
   Node* getParent() const { return m_parentNode; }
 
   /// Get my index in the parent node
   int row();
 
   /// Return the display name for the node.
   QString displayName() const { return m_displayName; }
 
   /// Returns a list of child nodes
   const QList<Node*>& getChildren() const { return m_children; }
 
   /// Return an icon representation for the node.
   /// @note It calls the internal getIcon and caches the result.
   QIcon getCachedIcon();
 
 public: // overridables
   /// Return a score when sorting the nodes.
   virtual int getScore() const = 0;
 
   /// Return true if the node contains sub-nodes.
   virtual bool hasChildren() const { return !m_children.empty(); }
 
   /// We use this string when sorting items.
   virtual QString getSortableString() const { return m_displayName; }
 
 protected:
   /// fill a_resultIcon with a display icon for the node.
   /// @param a_resultIcon returned icon.
   /// @return true if result was returned.
   virtual bool getIcon(QIcon& a_resultIcon) = 0;
 
 private:
   Node* m_parentNode;
 
   /// Called once the node has been populated to sort the entire tree / branch.
   void recursiveSortInternal();
 
 protected:
   typedef QList< Node* > NodesList;
   NodesList m_children;
   QString m_displayName;
   QIcon m_cachedIcon;
   NodesModelInterface* m_model;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Base class for nodes that generate and populate their child nodes dynamically
 class DynamicNode : public Node
 {
 public:
   DynamicNode(const QString& a_displayName, NodesModelInterface* a_model);
 
   /// Return true if the node was populated already.
   bool isPopulated() const { return m_populated; }
 
   /// Populate the node and mark the flag - called from expand or can be used internally.
   void performPopulateNode(bool a_forceRepopulate = false);
 
 public: // Node overrides.
   void collapse() override;
   void expand() override;
   bool hasChildren() const override;
 
 protected: // overridables
   /// Called by the framework when the node is about to be expanded
   /// it should be populated with sub-nodes if applicable.
   virtual void populateNode() {}
 
   /// Called after the nodes have been removed.
   /// It's for derived classes to clean cached data.
   virtual void nodeCleared() {}
 
 private:
   bool m_populated;
 
   /// Clear all the child nodes and mark flag.
   void performNodeCleanup();
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Base class for nodes associated with a @ref KDevelop::QualifiedIdentifier
 class IdentifierNode : public DynamicNode
 {
 public:
   IdentifierNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model, const QString& a_displayName = QString());
 
 public:
   /// Returns the qualified identifier for this node by going through the tree
   const KDevelop::IndexedQualifiedIdentifier& getIdentifier() const { return m_identifier; }
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
 
 public: // Overridables
   /// Return the associated declaration
   /// @note DU CHAIN MUST BE LOCKED FOR READ
   virtual KDevelop::Declaration* getDeclaration();
 
 private:
   KDevelop::IndexedQualifiedIdentifier m_identifier;
   KDevelop::IndexedDeclaration m_indexedDeclaration;
   KDevelop::DeclarationPointer m_cachedDeclaration;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// A node that represents an enum value.
 class EnumNode : public IdentifierNode
 {
 public:
   EnumNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
 
 public: // Node overrides
   int getScore() const override { return 102; }
   bool getIcon(QIcon& a_resultIcon) override;
   void populateNode() override;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides display for a single class.
 class ClassNode : public IdentifierNode, public ClassModelNodeDocumentChangedInterface
 {
 public:
   ClassNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
   ~ClassNode() override;
 
   /// Lookup a contained class and return the related node.
   /// @return the node pointer or 0 if non was found.
   ClassNode* findSubClass(const KDevelop::IndexedQualifiedIdentifier& a_id);
 
 public: // Node overrides
   int getScore() const override { return 300; }
   void populateNode() override;
   void nodeCleared() override;
   bool hasChildren() const override { return true; }
 
 protected: // ClassModelNodeDocumentChangedInterface overrides
   void documentChanged(const KDevelop::IndexedString& a_file) override;
 
 private:
   typedef QMap< uint, Node* > SubIdentifiersMap;
   /// Set of known sub-identifiers. It's used for updates check.
   SubIdentifiersMap m_subIdentifiers;
 
   /// We use this variable to know if we've registered for change notification or not.
   KDevelop::IndexedString m_cachedUrl;
 
   /// Updates the node to reflect changes in the declaration.
   /// @note DU CHAIN MUST BE LOCKED FOR READ
   /// @return true if something was updated.
   bool updateClassDeclarations();
 
   /// Add "Base classes" and "Derived classes" folders, if needed
   /// @return true if one of the folders was added.
   bool addBaseAndDerived();
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides a display for a single class function.
 class FunctionNode : public IdentifierNode
 {
 public:
   FunctionNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
 
 public: // Node overrides
   int getScore() const override { return 400; }
   QString getSortableString() const override { return m_sortableString; }
 
 private:
   QString m_sortableString;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides display for a single class variable.
 class ClassMemberNode : public IdentifierNode
 {
 public:
   ClassMemberNode(KDevelop::ClassMemberDeclaration* a_decl, NodesModelInterface* a_model);
 
 public: // Node overrides
   int getScore() const override { return 500; }
   bool getIcon(QIcon& a_resultIcon) override;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides a folder node with a static list of nodes.
 class FolderNode : public Node
 {
 public:
   FolderNode(const QString& a_displayName, NodesModelInterface* a_model);
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
   int getScore() const override { return 100; }
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides a folder node with a dynamic list of nodes.
 class DynamicFolderNode : public DynamicNode
 {
 public:
   DynamicFolderNode(const QString& a_displayName, NodesModelInterface* a_model);
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
   int getScore() const override { return 100; }
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Special folder - the parent is assumed to be a ClassNode.
 /// It then displays the base classes for the class it sits in.
 class BaseClassesFolderNode : public DynamicFolderNode
 {
 public:
   explicit BaseClassesFolderNode(NodesModelInterface* a_model);
 
 public: // Node overrides
   void populateNode() override;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Special folder - the parent is assumed to be a ClassNode.
 /// It then displays list of derived classes from the parent class.
 class DerivedClassesFolderNode : public DynamicFolderNode
 {
 public:
   explicit DerivedClassesFolderNode(NodesModelInterface* a_model);
 
 public: // Node overrides
   void populateNode() override;
 };
 
 } // namespace classModelNodes
 
 #endif
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
diff --git a/kdevplatform/language/duchain/navigation/problemnavigationcontext.h b/kdevplatform/language/duchain/navigation/problemnavigationcontext.h
index 33238e993a..1351ace577 100644
--- a/kdevplatform/language/duchain/navigation/problemnavigationcontext.h
+++ b/kdevplatform/language/duchain/navigation/problemnavigationcontext.h
@@ -1,73 +1,74 @@
 /*
    Copyright 2009 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.
 */
 
 #ifndef KDEVPLATFORM_PROBLEMNAVIGATIONCONTEXT_H
 #define KDEVPLATFORM_PROBLEMNAVIGATIONCONTEXT_H
 
 #include <interfaces/iproblem.h>
 #include <interfaces/iassistant.h>
 
 #include <language/duchain/navigation/abstractnavigationcontext.h>
 #include <language/languageexport.h>
-#include <qpointer.h>
+
+#include <QPointer>
 
 namespace KDevelop {
 
 class KDEVPLATFORMLANGUAGE_EXPORT ProblemNavigationContext : public AbstractNavigationContext
 {
   Q_OBJECT
   public:
     enum Flag {
       NoFlag = 0,
       ShowLocation = 1 << 0,
     };
     Q_DECLARE_FLAGS(Flags, Flag)
 
     explicit ProblemNavigationContext(const QVector<IProblem::Ptr>& problems, const Flags flags = {});
     ~ProblemNavigationContext() override;
 
     QString name() const override;
     QString html(bool shorten = false) override;
     QWidget* widget() const override;
     bool isWidgetMaximized() const override;
 
     NavigationContextPointer executeKeyAction(const QString& key) override;
 
 public Q_SLOTS:
     void executeAction(int index); // TODO: Add API in base class?
 
   private:
     void html(IProblem::Ptr problem);
 
     /**
      * Return HTML-ized text. Used for processing problem's description and explanation.
      * Some plugins (kdev-cppcheck for example) return already HTML-ized strings,
      * therefore we should make check for this case.
      */
     QString escapedHtml(const QString& text) const;
 
     QVector<IProblem::Ptr> m_problems;
     Flags m_flags;
 
     QPointer<QWidget> m_widget;
     QVector<IAssistantAction::Ptr> m_assistantsActions;
 };
 
 }
 
 #endif // KDEVPLATFORM_PROBLEMNAVIGATIONCONTEXT_H
diff --git a/kdevplatform/tests/kdevsignalspy.cpp b/kdevplatform/tests/kdevsignalspy.cpp
index 7fdc74434a..16fe568dbd 100644
--- a/kdevplatform/tests/kdevsignalspy.cpp
+++ b/kdevplatform/tests/kdevsignalspy.cpp
@@ -1,62 +1,63 @@
 /*
  * This file is part of KDevelop
  * Copyright 2008 Manuel Breugelmans <mbr.nxi@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 
 #include "kdevsignalspy.h"
-#include <qeventloop.h>
-#include <qtimer.h>
+
+#include <QEventLoop>
+#include <QTimer>
 
 namespace KDevelop
 {
 
 KDevSignalSpy::KDevSignalSpy(QObject *obj, const char *signal,
               Qt::ConnectionType ct )
   : QObject(nullptr), m_obj(obj), m_emitted(false) 
 {
     m_timer = new QTimer(this);
     m_loop = new QEventLoop(this);
     connect(obj, signal, this, SLOT(signalEmitted()), ct);
 }
 
 bool KDevSignalSpy::wait(int timeout)
 {
     Q_ASSERT(!m_loop->isRunning()); Q_ASSERT(!m_timer->isActive());
 
     m_emitted = false;
     if (timeout > 0) {
         connect(m_timer, &QTimer::timeout, m_loop, &QEventLoop::quit);
         m_timer->setSingleShot(true);
         m_timer->start(timeout);
     }
     m_loop->exec();
 
     return m_emitted;
 }
 
 void KDevSignalSpy::signalEmitted()
 {
     m_emitted = true;
     disconnect(m_obj, nullptr, this, nullptr);
     m_timer->stop();
     m_loop->quit();
 }
 
 } // KDevelop
 
 
diff --git a/kdevplatform/vcs/interfaces/ipatchsource.h b/kdevplatform/vcs/interfaces/ipatchsource.h
index 78597ffad5..e9b8f104c9 100644
--- a/kdevplatform/vcs/interfaces/ipatchsource.h
+++ b/kdevplatform/vcs/interfaces/ipatchsource.h
@@ -1,113 +1,113 @@
 /*
    Copyright 2006 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.
 */
 
 #ifndef KDEVPLATFORM_IPATCHSOURCE_H
 #define KDEVPLATFORM_IPATCHSOURCE_H
 
-#include <QUrl>
-#include <QMap>
-
-#include <qpointer.h>
 #include <vcs/vcsexport.h>
 #include <vcs/vcsstatusinfo.h>
 
+#include <QUrl>
+#include <QMap>
+#include <QPointer>
+
 namespace KDevelop {
 
 ///Any entity may delete an IPatchSource based object at will, so it must always be referenced through a QPointer (Just use IPatchSource::Ptr).
 class KDEVPLATFORMVCS_EXPORT IPatchSource : public QObject
 {
     Q_OBJECT
     public:
         typedef QPointer<IPatchSource> Ptr;
 
         ///Name of the patch, that will be shown in a combo box. Should
         ///describe the patch in a useful way, for example "Difference to base in kdevplatform/language"
         virtual QString name() const = 0;
 
         ///Icon that will be shown with the patch
         virtual QIcon icon() const;
 
         ///Should tell if the patch is already applied on the local version.
         virtual bool isAlreadyApplied() const = 0;
 
         ///Explicit updating of the patch: If it is a dynamic patch, it
         ///should re-compare the files or whatever needs to be done
         ///If the patch has changed, patchChanged needs to be emitted
         virtual void update() = 0;
 
         ///Name of the patch file
         virtual QUrl file() const = 0;
 
         ///Should return the base-dir of the patch
         virtual QUrl baseDir() const = 0;
 
         ///Can return a custom widget that should be shown to the user with this patch
         ///The ownership of the widget is shared between the caller and the patch-source (both may delete it at will)
         ///The default implementation returns zero
         virtual QWidget* customWidget() const;
 
         ///May return a custom text for the "Finish Review" action.
         ///The default implementation returns QString(), which means that the default is used
         virtual QString finishReviewCustomText() const;
 
         ///Called when the user has reviewed and accepted this patch
         ///If canSelectFiles() returned true, @p selection will contain the list of selected files
         ///If this returns false, the review is not finished.
         virtual bool finishReview(const QList<QUrl>& selection);
 
         ///Called when the user has rejected this patch
         virtual void cancelReview();
 
         ///Should return whether the user may cancel this review (cancelReview will be called when he does)
         ///The default implementation returns false
         virtual bool canCancel() const;
 
         ///Should return whether the user should be able to select files of the patch
         ///The files available for selection will be all files affected by the patch, and the files
         ///return by additionalSelectableFiles() The default implementation returns false
         virtual bool canSelectFiles() const;
 
         ///May return an additional list of selectable files together with short description strings for this patch
         ///The default implementation returns an empty list
         virtual QMap<QUrl, KDevelop::VcsStatusInfo::State> additionalSelectableFiles() const;
 
         /// Depth - number of directories to left-strip from paths in the patch - see "patch -p"
         /// Defaults to 0
         virtual uint depth() const;
     Q_SIGNALS:
         ///Should be emitted whenever the patch has changed.
         void patchChanged();
 };
 
 class KDEVPLATFORMVCS_EXPORT IPatchReview
 {
     public:
         virtual ~IPatchReview();
 
         enum ReviewMode {
             OpenAndRaise ///< Opens the related files in the review area, switches to that area, and raises the patch-review tool view
         };
         ///Starts a review on the patch: Opens the patch and the files within the review area
         virtual void startReview(IPatchSource* patch, ReviewMode mode = OpenAndRaise) = 0;
 };
 
 }
 
 Q_DECLARE_INTERFACE(KDevelop::IPatchReview, "org.kdevelop.IPatchReview")
 
 #endif // KDEVPLATFORM_IPATCHSOURCE_H
diff --git a/plugins/cmake/parser/cmStandardLexer.h b/plugins/cmake/parser/cmStandardLexer.h
index 088452a8dd..c489c0303e 100644
--- a/plugins/cmake/parser/cmStandardLexer.h
+++ b/plugins/cmake/parser/cmStandardLexer.h
@@ -1,60 +1,60 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #ifndef cmStandardLexer_h
 #define cmStandardLexer_h
 
-#include <qglobal.h>
+#include <QtGlobal>
 
 /* Disable some warnings.  */
 #if defined(_MSC_VER)
 #pragma warning(disable : 4018)
 #pragma warning(disable : 4127)
 #pragma warning(disable : 4131)
 #pragma warning(disable : 4244)
 #pragma warning(disable : 4251)
 #pragma warning(disable : 4267)
 #pragma warning(disable : 4305)
 #pragma warning(disable : 4309)
 #pragma warning(disable : 4706)
 #pragma warning(disable : 4786)
 #endif
 
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 #if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 402
 #pragma GCC diagnostic ignored "-Wconversion"
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #endif
 #if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 403
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 #endif
 
 /* Make sure isatty is available. */
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #include <io.h>
 #if defined(_MSC_VER)
 #define isatty _isatty
 #endif
 #else
 #include <unistd.h> /* IWYU pragma: export */
 #endif
 
 /* Make sure malloc and free are available on QNX.  */
 #ifdef __QNX__
 #include <malloc.h>
 #endif
 
 /* Disable features we do not need. */
 #define YY_NEVER_INTERACTIVE 1
 #define YY_NO_INPUT 1
 #define YY_NO_UNPUT 1
 #define ECHO
 
 typedef qint8 flex_int8_t;
 typedef quint8 flex_uint8_t;
 typedef qint16 flex_int16_t;
 typedef quint16 flex_uint16_t;
 typedef qint32 flex_int32_t;
 typedef quint32 flex_uint32_t;
 
 #endif
diff --git a/plugins/custom-buildsystem/tests/kcmuitestmain.cpp b/plugins/custom-buildsystem/tests/kcmuitestmain.cpp
index 776ad690ee..3a9fa4b40a 100644
--- a/plugins/custom-buildsystem/tests/kcmuitestmain.cpp
+++ b/plugins/custom-buildsystem/tests/kcmuitestmain.cpp
@@ -1,143 +1,143 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2012 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include <KLocalizedString>
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QTemporaryDir>
-#include <qdir.h>
+#include <QDir>
 #include <QPushButton>
 #include <QStandardPaths>
 
 #include <tests/testproject.h>
 #include <QApplication>
 #include <KAboutData>
 #include <QCommandLineParser>
 #include <KConfig>
 
 #include "custombuildsystemconfigwidget.h"
 #include <debug.h>
 
 static const char description[] =
     I18N_NOOP("CustomBuildSystem Config Ui Test App");
 
 static const char version[] = "0.1";
 
 class State : public QObject
 {
 Q_OBJECT
 public:
     State( QDialogButtonBox* buttonBox, CustomBuildSystemConfigWidget* cfgWidget, KConfig* config, KDevelop::IProject* proj )
         : buttonBox(buttonBox), configWidget(cfgWidget), cfg(config), project(proj)
     {
         connect(buttonBox, &QDialogButtonBox::clicked, this, &State::buttonClicked);
         connect(configWidget, &CustomBuildSystemConfigWidget::changed, this, &State::configChanged);
     }
 public Q_SLOTS:
     void buttonClicked(QAbstractButton* button)
     {
         if (button == buttonBox->button(QDialogButtonBox::Apply)) {
             apply();
         } else if (button == buttonBox->button(QDialogButtonBox::Ok)) {
             ok();
         } else if (button == buttonBox->button(QDialogButtonBox::Cancel)) {
             qApp->quit();
         }
     }
 
     void apply() {
         configWidget->saveTo(cfg, project);
         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
         buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
     }
     void ok() {
         apply();
         qApp->quit();
     }
     void configChanged() {
         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
         buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
     }
 private:
     QDialogButtonBox* buttonBox;
     CustomBuildSystemConfigWidget* configWidget;
     KConfig* cfg;
     KDevelop::IProject* project;
 };
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
 
     KAboutData aboutData(QStringLiteral("kcm_uitest"), i18n("kcm_uitest"), version, i18n(description),
                      KAboutLicense::GPL, i18n("(C) 2012 Andreas Pakulat"));
     aboutData.addAuthor( i18n("Andreas Pakulat"), QString(), QStringLiteral("apaku@gmx.de") );
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
 
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     QTemporaryDir tempdir(QStandardPaths::writableLocation(QStandardPaths::TempLocation)+"/kdev-custom-uitest");
 
     qCDebug(CUSTOMBUILDSYSTEM) << "created tempdir:" << tempdir.path();
 
     KConfig projkcfg( tempdir.path() + "/kdev-custom-uitest.kdev4" );
 
     QDir projdir(tempdir.path());
     projdir.mkdir(QStringLiteral("includedir"));
     projdir.mkdir(QStringLiteral("subtree"));
     projdir.mkpath(QStringLiteral("subtree/includedir"));
     projdir.mkpath(QStringLiteral("subtree/deeptree"));
     projdir.mkpath(QStringLiteral("subtree/deeptree/includedir"));
 
     qCDebug(CUSTOMBUILDSYSTEM) << "project config:" << projkcfg.name();
 
     QDialog dlg;
 
     QVBoxLayout mainLayout;
     dlg.setLayout(&mainLayout);
 
     KDevelop::TestProject proj;
     proj.setPath( KDevelop::Path(projkcfg.name()));
 
     CustomBuildSystemConfigWidget widget(nullptr);
     widget.loadFrom(&projkcfg);
     mainLayout.addWidget(&widget);
 
     dlg.setWindowTitle(QStringLiteral("Ui Test App for Config Widget"));
 
     QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Apply | QDialogButtonBox::Cancel);
     buttonBox.button(QDialogButtonBox::Apply)->setEnabled(false);
     buttonBox.button(QDialogButtonBox::Ok)->setEnabled(false);
 
     State state(&buttonBox, &widget, &projkcfg, &proj );
 
     dlg.resize(800, 600);
 
     dlg.show();
 
     return app.exec();
 
 }
 
 #include "kcmuitestmain.moc"
diff --git a/plugins/cvs/cvsplugin.h b/plugins/cvs/cvsplugin.h
index b7fd987deb..50f37c0b42 100644
--- a/plugins/cvs/cvsplugin.h
+++ b/plugins/cvs/cvsplugin.h
@@ -1,137 +1,138 @@
 /***************************************************************************
  *   Copyright 2007 Robert Gruber <rgruber@users.sourceforge.net>          *
  *                                                                         *
  *   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_PLUGIN_CVSPLUGIN_H
 #define KDEVPLATFORM_PLUGIN_CVSPLUGIN_H
 
-#include <QUrl>
-#include <KJob>
-
 #include <vcs/interfaces/icentralizedversioncontrol.h>
 #include <vcs/vcslocation.h>
 #include <interfaces/iplugin.h>
-#include <qobject.h>
+
+#include <KJob>
+
+#include <QUrl>
+#include <QObject>
 
 class CvsProxy;
 
 /**
  * This is the main class of KDevelop's CVS plugin.
  *
  * It implements the IVersionControl interface.
  *
  * @author Robert Gruber <rgruber@users.sourceforge.net>
  */
 class CvsPlugin : public KDevelop::IPlugin, public KDevelop::ICentralizedVersionControl
 {
     Q_OBJECT
     Q_INTERFACES(KDevelop::IBasicVersionControl KDevelop::ICentralizedVersionControl)
 
     friend class CvsProxy;
 
 public:
     explicit CvsPlugin(QObject *parent, const QVariantList & args = QVariantList());
     ~CvsPlugin() override;
 
     void unload() override;
 
     QString name() const override;
     KDevelop::VcsImportMetadataWidget* createImportMetadataWidget(QWidget* parent) override;
 
     // From KDevelop::IPlugin
     KDevelop::ContextMenuExtension contextMenuExtension(KDevelop::Context* context, QWidget* parent) override;
 
     // Begin:  KDevelop::IBasicVersionControl
     bool isValidRemoteRepositoryUrl(const QUrl& remoteLocation) override;
     bool isVersionControlled(const QUrl& localLocation) override;
     KDevelop::VcsJob* repositoryLocation(const QUrl& localLocation) override;
     KDevelop::VcsJob* add(const QList<QUrl>& localLocations,
                                   KDevelop::IBasicVersionControl::RecursionMode recursion) override;
     KDevelop::VcsJob* remove(const QList<QUrl>& localLocations) override;
     KDevelop::VcsJob* copy(const QUrl& localLocationSrc,
                                    const QUrl& localLocationDstn) override;
     KDevelop::VcsJob* move(const QUrl& localLocationSrc,
                                    const QUrl& localLocationDst) override;
     KDevelop::VcsJob* status(const QList<QUrl>& localLocations,
                                      KDevelop::IBasicVersionControl::RecursionMode recursion) override;
     KDevelop::VcsJob* revert(const QList<QUrl>& localLocations,
                                      KDevelop::IBasicVersionControl::RecursionMode recursion) override;
     KDevelop::VcsJob* update(const QList<QUrl>& localLocations,
                                      const KDevelop::VcsRevision& rev,
                                      KDevelop::IBasicVersionControl::RecursionMode recursion) override;
     KDevelop::VcsJob* commit(const QString& message,
                                      const QList<QUrl>& localLocations,
                                      KDevelop::IBasicVersionControl::RecursionMode recursion) override;
     KDevelop::VcsJob* diff(const QUrl& fileOrDirectory,
                                    const KDevelop::VcsRevision& srcRevision,
                                    const KDevelop::VcsRevision& dstRevision,
                                    KDevelop::IBasicVersionControl::RecursionMode = KDevelop::IBasicVersionControl::Recursive) override;
     KDevelop::VcsJob* log(const QUrl& localLocation,
                                   const KDevelop::VcsRevision& rev,
                                   unsigned long limit) override;
     KDevelop::VcsJob* log(const QUrl& localLocation,
                                   const KDevelop::VcsRevision& rev,
                                   const KDevelop::VcsRevision& limit) override;
     KDevelop::VcsJob* annotate(const QUrl& localLocation,
                                        const KDevelop::VcsRevision& rev) override;
     KDevelop::VcsJob* resolve(const QList<QUrl>& localLocations,
                                       KDevelop::IBasicVersionControl::RecursionMode recursion) override;
     KDevelop::VcsJob* createWorkingCopy(const KDevelop::VcsLocation & sourceRepository, const QUrl & destinationDirectory, KDevelop::IBasicVersionControl::RecursionMode recursion = KDevelop::IBasicVersionControl::Recursive) override;
     // End:  KDevelop::IBasicVersionControl
 
     // Begin:  KDevelop::ICentralizedVersionControl
     KDevelop::VcsJob* edit(const QUrl& localLocation) override;
     KDevelop::VcsJob* unedit(const QUrl& localLocation) override;
     KDevelop::VcsJob* localRevision(const QUrl& localLocation,
                                             KDevelop::VcsRevision::RevisionType) override;
     KDevelop::VcsJob* import(const QString& commitMessage, const QUrl& sourceDirectory, const KDevelop::VcsLocation& destinationRepository) override;
 // End:  KDevelop::ICentralizedVersionControl
 
     CvsProxy* proxy();
 
     const QUrl urlFocusedDocument() const;
     KDevelop::VcsLocationWidget* vcsLocation(QWidget* parent) const override;
 public Q_SLOTS:
     // slots for context menu
     void ctxEdit();
     void ctxUnEdit();
     void ctxEditors();
 
     // slots for menu
     void slotImport();
     void slotCheckout();
     void slotStatus();
 
 Q_SIGNALS:
     /**
      * Some actions like commit, add, remove... will connect the job's
      * result() signal to this signal. Anybody, like for instance the
      * CvsMainView class, that is interested in getting notified about
      * jobs that finished can connect to this signal.
      * @see class CvsMainView
      */
     void jobFinished(KJob* job);
 
     /**
      * Gets emmited when a job like log, editors... was created.
      * CvsPlugin will connect the newly created view to the result() signal
      * of a job. So the new view will show the output of that job as
      * soon as it has finished.
      */
     void addNewTabToMainView(QWidget* tab, const QString& label);
 
 private:
     void setupActions();
     QString findWorkingDir(const QUrl& location);
 
 private:
     const QScopedPointer<class CvsPluginPrivate> d;
 };
 
 #endif
diff --git a/plugins/git/gitplugincheckinrepositoryjob.cpp b/plugins/git/gitplugincheckinrepositoryjob.cpp
index 5ec13e012f..9e43fb3a1c 100644
--- a/plugins/git/gitplugincheckinrepositoryjob.cpp
+++ b/plugins/git/gitplugincheckinrepositoryjob.cpp
@@ -1,93 +1,93 @@
 /***************************************************************************
  *   Copyright 2014 Sven Brauch <svenbrauch@gmail.com>                     *
  *                                                                         *
  *   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 "gitplugincheckinrepositoryjob.h"
 #include "debug.h"
 
 #include <KTextEditor/Document>
-#include <qtextcodec.h>
 
+#include <QTextCodec>
 #include <QDir>
 
 GitPluginCheckInRepositoryJob::GitPluginCheckInRepositoryJob(KTextEditor::Document* document,
                                                              const QString& rootDirectory)
     : CheckInRepositoryJob(document)
     , m_hashjob(nullptr)
     , m_findjob(nullptr)
     , m_rootDirectory(rootDirectory)
 {}
 
 void GitPluginCheckInRepositoryJob::start()
 {
     const QTextCodec* codec = QTextCodec::codecForName(document()->encoding().toLatin1());
 
     const QDir workingDirectory(m_rootDirectory);
     if ( !workingDirectory.exists() ) {
         emit finished(false);
         return;
     }
 
     m_findjob = new QProcess(this);
     m_findjob->setWorkingDirectory(m_rootDirectory);
 
     m_hashjob = new QProcess(this);
     m_hashjob->setWorkingDirectory(m_rootDirectory);
     m_hashjob->setStandardOutputProcess(m_findjob);
 
     connect(m_findjob, static_cast<void(QProcess::*)(int)>(&QProcess::finished), this, &GitPluginCheckInRepositoryJob::repositoryQueryFinished);
     connect(m_hashjob, static_cast<void(QProcess::*)(QProcess::ProcessError)>(&QProcess::error), this, &GitPluginCheckInRepositoryJob::processFailed);
     connect(m_findjob, static_cast<void(QProcess::*)(QProcess::ProcessError)>(&QProcess::error), this, &GitPluginCheckInRepositoryJob::processFailed);
 
     m_hashjob->start(QStringLiteral("git"), QStringList{QStringLiteral("hash-object"), QStringLiteral("--stdin")});
     m_findjob->start(QStringLiteral("git"), QStringList{QStringLiteral("cat-file"), QStringLiteral("--batch-check")});
 
     for ( int i = 0; i < document()->lines(); i++ ) {
         m_hashjob->write(codec->fromUnicode(document()->line(i)));
         if ( i != document()->lines() - 1 ) {
             m_hashjob->write("\n");
         }
     }
     m_hashjob->closeWriteChannel();
 
 }
 
 GitPluginCheckInRepositoryJob::~GitPluginCheckInRepositoryJob()
 {
     if ( m_findjob && m_findjob->state() == QProcess::Running ) {
         m_findjob->kill();
     }
     if ( m_hashjob && m_hashjob->state() == QProcess::Running ) {
         m_hashjob->kill();
     }
 }
 
 void GitPluginCheckInRepositoryJob::processFailed(QProcess::ProcessError err)
 {
     qCDebug(PLUGIN_GIT) << "calling git failed with error:" << err;
     emit finished(false);
 }
 
 void GitPluginCheckInRepositoryJob::repositoryQueryFinished(int)
 {
     const QByteArray output = m_findjob->readAllStandardOutput();
     bool requestSucceeded = output.contains(" blob ");
     emit finished(requestSucceeded);
 }
 
diff --git a/plugins/projectmanagerview/vcsoverlayproxymodel.h b/plugins/projectmanagerview/vcsoverlayproxymodel.h
index 025ad53660..8507424b12 100644
--- a/plugins/projectmanagerview/vcsoverlayproxymodel.h
+++ b/plugins/projectmanagerview/vcsoverlayproxymodel.h
@@ -1,54 +1,54 @@
 /* This file is part of KDevelop
     Copyright 2008 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.
 */
 
 #ifndef KDEVPLATFORM_PLUGIN_VCSOVERLAYPROXYMODEL_H
 #define KDEVPLATFORM_PLUGIN_VCSOVERLAYPROXYMODEL_H
 
-#include <qidentityproxymodel.h>
 #include <project/projectmodel.h>
+#include <QIdentityProxyModel>
 
 class QUrl;
 namespace KDevelop {
     class IProject;
     class VcsJob;
 }
 
 class VcsOverlayProxyModel : public QIdentityProxyModel
 {
     Q_OBJECT
     public:
         enum Roles {
             VcsStatusRole = KDevelop::ProjectModel::LastRole
         };
         explicit VcsOverlayProxyModel(QObject* parent = nullptr);
 
         QVariant data(const QModelIndex& proxyIndex, int role = Qt::DisplayRole) const override;
 
     private Q_SLOTS:
         void addProject(KDevelop::IProject* p);
         void removeProject(KDevelop::IProject* p);
         void repositoryBranchChanged(const QUrl& url);
         void branchNameReady(KDevelop::VcsJob* job);
 
     private:
         QModelIndex indexFromProject(QObject* project);
         QHash<KDevelop::IProject*, QString> m_branchName;
 };
 
 #endif // KDEVPLATFORM_PLUGIN_VCSOVERLAYPROXYMODEL_H
diff --git a/plugins/quickopen/quickopenplugin.cpp b/plugins/quickopen/quickopenplugin.cpp
index db3cc309e7..2e5321202f 100644
--- a/plugins/quickopen/quickopenplugin.cpp
+++ b/plugins/quickopen/quickopenplugin.cpp
@@ -1,1172 +1,1173 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2007 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 "quickopenplugin.h"
 
 #include "quickopenwidget.h"
 
 #include <cassert>
 #include <typeinfo>
 #include <QKeyEvent>
 #include <QApplication>
 #include <QMetaObject>
 #include <QWidgetAction>
 #include <QAction>
+#include <QDesktopWidget>
 
 #include <KLocalizedString>
 #include <KPluginFactory>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <KParts/MainWindow>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KActionCollection>
 
 #include <interfaces/icore.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/idocumentcontroller.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/types/identifiedtype.h>
 #include <serialization/indexedstring.h>
 #include <language/duchain/types/functiontype.h>
 
 #include "quickopenmodel.h"
 #include "projectfilequickopen.h"
 #include "projectitemquickopen.h"
 #include "declarationlistquickopen.h"
 #include "documentationquickopenprovider.h"
 #include "actionsquickopenprovider.h"
 #include "debug.h"
 #include <language/duchain/functiondefinition.h>
-#include <qdesktopwidget.h>
 #include <interfaces/contextmenuextension.h>
 #include <language/interfaces/codecontext.h>
 
+
 using namespace KDevelop;
 
 const bool noHtmlDestriptionInOutline = true;
 
 class QuickOpenWidgetCreator
 {
 public:
     virtual ~QuickOpenWidgetCreator()
     {
     }
     virtual QuickOpenWidget* createWidget() = 0;
     virtual QString objectNameForLine() = 0;
     virtual void widgetShown()
     {
     }
 };
 
 class StandardQuickOpenWidgetCreator
     : public QuickOpenWidgetCreator
 {
 public:
     StandardQuickOpenWidgetCreator(const QStringList& items, const QStringList& scopes)
         : m_items(items)
         , m_scopes(scopes)
     {
     }
 
     QString objectNameForLine() override
     {
         return QStringLiteral("Quickopen");
     }
 
     void setItems(const QStringList& scopes, const QStringList& items)
     {
         m_scopes = scopes;
         m_items = items;
     }
 
     QuickOpenWidget* createWidget() override
     {
         QStringList useItems = m_items;
         if (useItems.isEmpty()) {
             useItems = QuickOpenPlugin::self()->lastUsedItems;
         }
 
         QStringList useScopes = m_scopes;
         if (useScopes.isEmpty()) {
             useScopes = QuickOpenPlugin::self()->lastUsedScopes;
         }
 
         return new QuickOpenWidget(i18n("Quick Open"), QuickOpenPlugin::self()->m_model, QuickOpenPlugin::self()->lastUsedItems, useScopes, false, true);
     }
 
     QStringList m_items;
     QStringList m_scopes;
 };
 
 class OutlineFilter
     : public DUChainUtils::DUChainItemFilter
 {
 public:
     enum OutlineMode { Functions, FunctionsAndClasses };
     explicit OutlineFilter(QVector<DUChainItem>& _items, OutlineMode _mode = FunctionsAndClasses) : items(_items)
         , mode(_mode)
     {
     }
     bool accept(Declaration* decl) override
     {
         if (decl->range().isEmpty()) {
             return false;
         }
         bool collectable = mode == Functions ? decl->isFunctionDeclaration() : (decl->isFunctionDeclaration() || (decl->internalContext() && decl->internalContext()->type() == DUContext::Class));
         if (collectable) {
             DUChainItem item;
             item.m_item = IndexedDeclaration(decl);
             item.m_text = decl->toString();
             items << item;
 
             return true;
         } else {
             return false;
         }
     }
     bool accept(DUContext* ctx) override
     {
         if (ctx->type() == DUContext::Class || ctx->type() == DUContext::Namespace || ctx->type() == DUContext::Global || ctx->type() == DUContext::Other || ctx->type() == DUContext::Helper) {
             return true;
         } else {
             return false;
         }
     }
     QVector<DUChainItem>& items;
     OutlineMode mode;
 };
 
 K_PLUGIN_FACTORY_WITH_JSON(KDevQuickOpenFactory, "kdevquickopen.json", registerPlugin<QuickOpenPlugin>(); )
 
 Declaration * cursorDeclaration() {
     KTextEditor::View* view = ICore::self()->documentController()->activeTextDocumentView();
     if (!view) {
         return nullptr;
     }
 
     KDevelop::DUChainReadLocker lock(DUChain::lock());
 
     return DUChainUtils::declarationForDefinition(DUChainUtils::itemUnderCursor(view->document()->url(), KTextEditor::Cursor(view->cursorPosition())).declaration);
 }
 
 ///The first definition that belongs to a context that surrounds the current cursor
 Declaration* cursorContextDeclaration()
 {
     KTextEditor::View* view = ICore::self()->documentController()->activeTextDocumentView();
     if (!view) {
         return nullptr;
     }
 
     KDevelop::DUChainReadLocker lock(DUChain::lock());
 
     TopDUContext* ctx = DUChainUtils::standardContextForUrl(view->document()->url());
     if (!ctx) {
         return nullptr;
     }
 
     KTextEditor::Cursor cursor(view->cursorPosition());
 
     DUContext* subCtx = ctx->findContext(ctx->transformToLocalRevision(cursor));
 
     while (subCtx && !subCtx->owner())
         subCtx = subCtx->parentContext();
 
     Declaration* definition = nullptr;
 
     if (!subCtx || !subCtx->owner()) {
         definition = DUChainUtils::declarationInLine(cursor, ctx);
     } else {
         definition = subCtx->owner();
     }
 
     if (!definition) {
         return nullptr;
     }
 
     return definition;
 }
 
 //Returns only the name, no template-parameters or scope
 QString cursorItemText()
 {
     KDevelop::DUChainReadLocker lock(DUChain::lock());
 
     Declaration* decl = cursorDeclaration();
     if (!decl) {
         return QString();
     }
 
     IDocument* doc = ICore::self()->documentController()->activeDocument();
     if (!doc) {
         return QString();
     }
 
     TopDUContext* context = DUChainUtils::standardContextForUrl(doc->url());
 
     if (!context) {
         qCDebug(PLUGIN_QUICKOPEN) << "Got no standard context";
         return QString();
     }
 
     AbstractType::Ptr t = decl->abstractType();
     IdentifiedType* idType = dynamic_cast<IdentifiedType*>(t.data());
     if (idType && idType->declaration(context)) {
         decl = idType->declaration(context);
     }
 
     if (!decl->qualifiedIdentifier().isEmpty()) {
         return decl->qualifiedIdentifier().last().identifier().str();
     }
 
     return QString();
 }
 
 QuickOpenLineEdit* QuickOpenPlugin::createQuickOpenLineWidget()
 {
     return new QuickOpenLineEdit(new StandardQuickOpenWidgetCreator(QStringList(), QStringList()));
 }
 
 QuickOpenLineEdit* QuickOpenPlugin::quickOpenLine(const QString& name)
 {
     const QList<QuickOpenLineEdit*> lines = ICore::self()->uiController()->activeMainWindow()->findChildren<QuickOpenLineEdit*>(name);
     for (QuickOpenLineEdit* line : lines) {
         if (line->isVisible()) {
             return line;
         }
     }
 
     return nullptr;
 }
 
 static QuickOpenPlugin* staticQuickOpenPlugin = nullptr;
 
 QuickOpenPlugin* QuickOpenPlugin::self()
 {
     return staticQuickOpenPlugin;
 }
 
 void QuickOpenPlugin::createActionsForMainWindow(Sublime::MainWindow* /*window*/, QString& xmlFile, KActionCollection& actions)
 {
     xmlFile = QStringLiteral("kdevquickopen.rc");
 
     QAction* quickOpen = actions.addAction(QStringLiteral("quick_open"));
     quickOpen->setText(i18n("&Quick Open"));
     quickOpen->setIcon(QIcon::fromTheme(QStringLiteral("quickopen")));
     actions.setDefaultShortcut(quickOpen, Qt::CTRL | Qt::ALT | Qt::Key_Q);
     connect(quickOpen, &QAction::triggered, this, &QuickOpenPlugin::quickOpen);
 
     QAction* quickOpenFile = actions.addAction(QStringLiteral("quick_open_file"));
     quickOpenFile->setText(i18n("Quick Open &File"));
     quickOpenFile->setIcon(QIcon::fromTheme(QStringLiteral("quickopen-file")));
     actions.setDefaultShortcut(quickOpenFile, Qt::CTRL | Qt::ALT | Qt::Key_O);
     connect(quickOpenFile, &QAction::triggered, this, &QuickOpenPlugin::quickOpenFile);
 
     QAction* quickOpenClass = actions.addAction(QStringLiteral("quick_open_class"));
     quickOpenClass->setText(i18n("Quick Open &Class"));
     quickOpenClass->setIcon(QIcon::fromTheme(QStringLiteral("quickopen-class")));
     actions.setDefaultShortcut(quickOpenClass, Qt::CTRL | Qt::ALT | Qt::Key_C);
     connect(quickOpenClass, &QAction::triggered, this, &QuickOpenPlugin::quickOpenClass);
 
     QAction* quickOpenFunction = actions.addAction(QStringLiteral("quick_open_function"));
     quickOpenFunction->setText(i18n("Quick Open &Function"));
     quickOpenFunction->setIcon(QIcon::fromTheme(QStringLiteral("quickopen-function")));
     actions.setDefaultShortcut(quickOpenFunction, Qt::CTRL | Qt::ALT | Qt::Key_M);
     connect(quickOpenFunction, &QAction::triggered, this, &QuickOpenPlugin::quickOpenFunction);
 
     QAction* quickOpenAlreadyOpen = actions.addAction(QStringLiteral("quick_open_already_open"));
     quickOpenAlreadyOpen->setText(i18n("Quick Open &Already Open File"));
     quickOpenAlreadyOpen->setIcon(QIcon::fromTheme(QStringLiteral("quickopen-file")));
     connect(quickOpenAlreadyOpen, &QAction::triggered, this, &QuickOpenPlugin::quickOpenOpenFile);
 
     QAction* quickOpenDocumentation = actions.addAction(QStringLiteral("quick_open_documentation"));
     quickOpenDocumentation->setText(i18n("Quick Open &Documentation"));
     quickOpenDocumentation->setIcon(QIcon::fromTheme(QStringLiteral("quickopen-documentation")));
     actions.setDefaultShortcut(quickOpenDocumentation, Qt::CTRL | Qt::ALT | Qt::Key_D);
     connect(quickOpenDocumentation, &QAction::triggered, this, &QuickOpenPlugin::quickOpenDocumentation);
 
     QAction* quickOpenActions = actions.addAction(QStringLiteral("quick_open_actions"));
     quickOpenActions->setText(i18n("Quick Open &Actions"));
     actions.setDefaultShortcut(quickOpenActions, Qt::CTRL | Qt::ALT | Qt::Key_A);
     connect(quickOpenActions, &QAction::triggered, this, &QuickOpenPlugin::quickOpenActions);
 
     m_quickOpenDeclaration = actions.addAction(QStringLiteral("quick_open_jump_declaration"));
     m_quickOpenDeclaration->setText(i18n("Jump to Declaration"));
     m_quickOpenDeclaration->setIcon(QIcon::fromTheme(QStringLiteral("go-jump-declaration")));
     actions.setDefaultShortcut(m_quickOpenDeclaration, Qt::CTRL | Qt::Key_Period);
     connect(m_quickOpenDeclaration, &QAction::triggered, this, &QuickOpenPlugin::quickOpenDeclaration, Qt::QueuedConnection);
 
     m_quickOpenDefinition = actions.addAction(QStringLiteral("quick_open_jump_definition"));
     m_quickOpenDefinition->setText(i18n("Jump to Definition"));
     m_quickOpenDefinition->setIcon(QIcon::fromTheme(QStringLiteral("go-jump-definition")));
     actions.setDefaultShortcut(m_quickOpenDefinition, Qt::CTRL | Qt::Key_Comma);
     connect(m_quickOpenDefinition, &QAction::triggered, this, &QuickOpenPlugin::quickOpenDefinition, Qt::QueuedConnection);
 
     QWidgetAction* quickOpenLine = new QWidgetAction(this);
     quickOpenLine->setText(i18n("Embedded Quick Open"));
     //     actions.setDefaultShortcut( quickOpenLine, Qt::CTRL | Qt::ALT | Qt::Key_E );
 //     connect(quickOpenLine, SIGNAL(triggered(bool)), this, SLOT(quickOpenLine(bool)));
     quickOpenLine->setDefaultWidget(createQuickOpenLineWidget());
     actions.addAction(QStringLiteral("quick_open_line"), quickOpenLine);
 
     QAction* quickOpenNextFunction = actions.addAction(QStringLiteral("quick_open_next_function"));
     quickOpenNextFunction->setText(i18n("Next Function"));
     actions.setDefaultShortcut(quickOpenNextFunction, Qt::CTRL | Qt::ALT | Qt::Key_PageDown);
     connect(quickOpenNextFunction, &QAction::triggered, this, &QuickOpenPlugin::nextFunction);
 
     QAction* quickOpenPrevFunction = actions.addAction(QStringLiteral("quick_open_prev_function"));
     quickOpenPrevFunction->setText(i18n("Previous Function"));
     actions.setDefaultShortcut(quickOpenPrevFunction, Qt::CTRL | Qt::ALT | Qt::Key_PageUp);
     connect(quickOpenPrevFunction, &QAction::triggered, this, &QuickOpenPlugin::previousFunction);
 
     QAction* quickOpenNavigateFunctions = actions.addAction(QStringLiteral("quick_open_outline"));
     quickOpenNavigateFunctions->setText(i18n("Outline"));
     actions.setDefaultShortcut(quickOpenNavigateFunctions, Qt::CTRL | Qt::ALT | Qt::Key_N);
     connect(quickOpenNavigateFunctions, &QAction::triggered, this, &QuickOpenPlugin::quickOpenNavigateFunctions);
 }
 
 QuickOpenPlugin::QuickOpenPlugin(QObject* parent,
                                  const QVariantList&)
     : KDevelop::IPlugin(QStringLiteral("kdevquickopen"), parent)
 {
     staticQuickOpenPlugin = this;
     m_model = new QuickOpenModel(nullptr);
 
     KConfigGroup quickopengrp = KSharedConfig::openConfig()->group("QuickOpen");
     lastUsedScopes = quickopengrp.readEntry("SelectedScopes", QStringList{
         i18n("Project"),
         i18n("Includes"),
         i18n("Includers"),
         i18n("Currently Open")});
     lastUsedItems = quickopengrp.readEntry("SelectedItems", QStringList());
 
     {
         m_openFilesData = new OpenFilesDataProvider();
         QStringList scopes, items;
         scopes << i18n("Currently Open");
         items << i18n("Files");
         m_model->registerProvider(scopes, items, m_openFilesData);
     }
     {
         m_projectFileData = new ProjectFileDataProvider();
         QStringList scopes, items;
         scopes << i18n("Project");
         items << i18n("Files");
         m_model->registerProvider(scopes, items, m_projectFileData);
     }
     {
         m_projectItemData = new ProjectItemDataProvider(this);
         QStringList scopes, items;
         scopes << i18n("Project");
         items << ProjectItemDataProvider::supportedItemTypes();
         m_model->registerProvider(scopes, items, m_projectItemData);
     }
     {
         m_documentationItemData = new DocumentationQuickOpenProvider;
         QStringList scopes, items;
         scopes << i18n("Includes");
         items << i18n("Documentation");
         m_model->registerProvider(scopes, items, m_documentationItemData);
     }
     {
         m_actionsItemData = new ActionsQuickOpenProvider;
         QStringList scopes, items;
         scopes << i18n("Includes");
         items << i18n("Actions");
         m_model->registerProvider(scopes, items, m_actionsItemData);
     }
 }
 
 QuickOpenPlugin::~QuickOpenPlugin()
 {
     freeModel();
 
     delete m_model;
     delete m_projectFileData;
     delete m_projectItemData;
     delete m_openFilesData;
     delete m_documentationItemData;
     delete m_actionsItemData;
 }
 
 void QuickOpenPlugin::unload()
 {
 }
 
 ContextMenuExtension QuickOpenPlugin::contextMenuExtension(Context* context, QWidget* parent)
 {
     KDevelop::ContextMenuExtension menuExt = KDevelop::IPlugin::contextMenuExtension(context, parent);
 
     KDevelop::DeclarationContext* codeContext = dynamic_cast<KDevelop::DeclarationContext*>(context);
 
     if (!codeContext) {
         return menuExt;
     }
 
     DUChainReadLocker readLock;
     Declaration* decl(codeContext->declaration().data());
 
     if (decl) {
         const bool isDef = FunctionDefinition::definition(decl);
         if (codeContext->use().isValid() || !isDef) {
             menuExt.addAction(KDevelop::ContextMenuExtension::NavigationGroup, m_quickOpenDeclaration);
         }
 
         if (isDef) {
             menuExt.addAction(KDevelop::ContextMenuExtension::NavigationGroup, m_quickOpenDefinition);
         }
     }
 
     return menuExt;
 }
 
 void QuickOpenPlugin::showQuickOpen(const QStringList& items)
 {
     if (!freeModel()) {
         return;
     }
 
     QStringList initialItems = items;
 
     QStringList useScopes = lastUsedScopes;
 
     if (!useScopes.contains(i18n("Currently Open"))) {
         useScopes << i18n("Currently Open");
     }
 
     showQuickOpenWidget(initialItems, useScopes, false);
 }
 
 void QuickOpenPlugin::showQuickOpen(ModelTypes modes)
 {
     if (!freeModel()) {
         return;
     }
 
     QStringList initialItems;
     if (modes & Files || modes & OpenFiles) {
         initialItems << i18n("Files");
     }
 
     if (modes & Functions) {
         initialItems << i18n("Functions");
     }
 
     if (modes & Classes) {
         initialItems << i18n("Classes");
     }
 
     QStringList useScopes;
     if (modes != OpenFiles) {
         useScopes = lastUsedScopes;
     }
 
     if ((modes & OpenFiles) && !useScopes.contains(i18n("Currently Open"))) {
         useScopes << i18n("Currently Open");
     }
 
     bool preselectText = (!(modes & Files) || modes == QuickOpenPlugin::All);
     showQuickOpenWidget(initialItems, useScopes, preselectText);
 }
 
 void QuickOpenPlugin::showQuickOpenWidget(const QStringList& items, const QStringList& scopes, bool preselectText)
 {
     QuickOpenWidgetDialog* dialog = new QuickOpenWidgetDialog(i18n("Quick Open"), m_model, items, scopes);
     m_currentWidgetHandler = dialog;
     if (preselectText) {
         KDevelop::IDocument* currentDoc = core()->documentController()->activeDocument();
         if (currentDoc && currentDoc->isTextDocument()) {
             QString preselected = currentDoc->textSelection().isEmpty() ? currentDoc->textWord() : currentDoc->textDocument()->text(currentDoc->textSelection());
             dialog->widget()->setPreselectedText(preselected);
         }
     }
 
     connect(dialog->widget(), &QuickOpenWidget::scopesChanged, this, &QuickOpenPlugin::storeScopes);
     //Not connecting itemsChanged to storeItems, as showQuickOpen doesn't use lastUsedItems and so shouldn't store item changes
     //connect( dialog->widget(), SIGNAL(itemsChanged(QStringList)), this, SLOT(storeItems(QStringList)) );
     dialog->widget()->ui.itemsButton->setEnabled(false);
 
     if (quickOpenLine()) {
         quickOpenLine()->showWithWidget(dialog->widget());
         dialog->deleteLater();
     } else {
         dialog->run();
     }
 }
 
 void QuickOpenPlugin::storeScopes(const QStringList& scopes)
 {
     lastUsedScopes = scopes;
     KConfigGroup grp = KSharedConfig::openConfig()->group("QuickOpen");
     grp.writeEntry("SelectedScopes", scopes);
 }
 
 void QuickOpenPlugin::storeItems(const QStringList& items)
 {
     lastUsedItems = items;
     KConfigGroup grp = KSharedConfig::openConfig()->group("QuickOpen");
     grp.writeEntry("SelectedItems", items);
 }
 
 void QuickOpenPlugin::quickOpen()
 {
     if (quickOpenLine()) { //Same as clicking on Quick Open
         quickOpenLine()->setFocus();
     } else {
         showQuickOpen(All);
     }
 }
 
 void QuickOpenPlugin::quickOpenFile()
 {
     showQuickOpen(( ModelTypes )(Files | OpenFiles));
 }
 
 void QuickOpenPlugin::quickOpenFunction()
 {
     showQuickOpen(Functions);
 }
 
 void QuickOpenPlugin::quickOpenClass()
 {
     showQuickOpen(Classes);
 }
 
 void QuickOpenPlugin::quickOpenOpenFile()
 {
     showQuickOpen(OpenFiles);
 }
 
 void QuickOpenPlugin::quickOpenDocumentation()
 {
     showQuickOpenWidget(QStringList(i18n("Documentation")), QStringList(i18n("Includes")), true);
 }
 
 void QuickOpenPlugin::quickOpenActions()
 {
     showQuickOpenWidget(QStringList(i18n("Actions")), QStringList(i18n("Includes")), true);
 }
 
 QSet<KDevelop::IndexedString> QuickOpenPlugin::fileSet() const
 {
     return m_model->fileSet();
 }
 
 void QuickOpenPlugin::registerProvider(const QStringList& scope, const QStringList& type, KDevelop::QuickOpenDataProviderBase* provider)
 {
     m_model->registerProvider(scope, type, provider);
 }
 
 bool QuickOpenPlugin::removeProvider(KDevelop::QuickOpenDataProviderBase* provider)
 {
     m_model->removeProvider(provider);
     return true;
 }
 
 void QuickOpenPlugin::quickOpenDeclaration()
 {
     if (jumpToSpecialObject()) {
         return;
     }
 
     KDevelop::DUChainReadLocker lock(DUChain::lock());
     Declaration* decl = cursorDeclaration();
 
     if (!decl) {
         qCDebug(PLUGIN_QUICKOPEN) << "Found no declaration for cursor, cannot jump";
         return;
     }
     decl->activateSpecialization();
 
     IndexedString u = decl->url();
     KTextEditor::Cursor c = decl->rangeInCurrentRevision().start();
 
     if (u.isEmpty()) {
         qCDebug(PLUGIN_QUICKOPEN) << "Got empty url for declaration" << decl->toString();
         return;
     }
 
     lock.unlock();
     core()->documentController()->openDocument(u.toUrl(), c);
 }
 
 QWidget* QuickOpenPlugin::specialObjectNavigationWidget() const
 {
     KTextEditor::View* view = ICore::self()->documentController()->activeTextDocumentView();
     if (!view) {
         return nullptr;
     }
 
     QUrl url = ICore::self()->documentController()->activeDocument()->url();
 
     const auto languages = ICore::self()->languageController()->languagesForUrl(url);
     for (const auto language : languages) {
         QWidget* w = language->specialLanguageObjectNavigationWidget(url, KTextEditor::Cursor(view->cursorPosition()));
         if (w) {
             return w;
         }
     }
 
     return nullptr;
 }
 
 QPair<QUrl, KTextEditor::Cursor> QuickOpenPlugin::specialObjectJumpPosition() const
 {
     KTextEditor::View* view = ICore::self()->documentController()->activeTextDocumentView();
     if (!view) {
         return qMakePair(QUrl(), KTextEditor::Cursor());
     }
 
     QUrl url = ICore::self()->documentController()->activeDocument()->url();
     const auto languages = ICore::self()->languageController()->languagesForUrl(url);
     for (const auto language : languages) {
         QPair<QUrl, KTextEditor::Cursor> pos = language->specialLanguageObjectJumpCursor(url, KTextEditor::Cursor(view->cursorPosition()));
         if (pos.second.isValid()) {
             return pos;
         }
     }
 
     return qMakePair(QUrl(), KTextEditor::Cursor::invalid());
 }
 
 bool QuickOpenPlugin::jumpToSpecialObject()
 {
     QPair<QUrl, KTextEditor::Cursor> pos = specialObjectJumpPosition();
     if (pos.second.isValid()) {
         if (pos.first.isEmpty()) {
             qCDebug(PLUGIN_QUICKOPEN) << "Got empty url for special language object";
             return false;
         }
 
         ICore::self()->documentController()->openDocument(pos.first, pos.second);
         return true;
     }
     return false;
 }
 
 void QuickOpenPlugin::quickOpenDefinition()
 {
     if (jumpToSpecialObject()) {
         return;
     }
 
     KDevelop::DUChainReadLocker lock(DUChain::lock());
     Declaration* decl = cursorDeclaration();
 
     if (!decl) {
         qCDebug(PLUGIN_QUICKOPEN) << "Found no declaration for cursor, cannot jump";
         return;
     }
 
     IndexedString u = decl->url();
     KTextEditor::Cursor c = decl->rangeInCurrentRevision().start();
     if (FunctionDefinition* def = FunctionDefinition::definition(decl)) {
         def->activateSpecialization();
         u = def->url();
         c = def->rangeInCurrentRevision().start();
     } else {
         qCDebug(PLUGIN_QUICKOPEN) << "Found no definition for declaration";
         decl->activateSpecialization();
     }
 
     if (u.isEmpty()) {
         qCDebug(PLUGIN_QUICKOPEN) << "Got empty url for declaration" << decl->toString();
         return;
     }
 
     lock.unlock();
     core()->documentController()->openDocument(u.toUrl(), c);
 }
 
 bool QuickOpenPlugin::freeModel()
 {
     if (m_currentWidgetHandler) {
         delete m_currentWidgetHandler;
     }
     m_currentWidgetHandler = nullptr;
 
     return true;
 }
 
 void QuickOpenPlugin::nextFunction()
 {
     jumpToNearestFunction(NextFunction);
 }
 
 void QuickOpenPlugin::previousFunction()
 {
     jumpToNearestFunction(PreviousFunction);
 }
 
 void QuickOpenPlugin::jumpToNearestFunction(QuickOpenPlugin::FunctionJumpDirection direction)
 {
     IDocument* doc = ICore::self()->documentController()->activeDocument();
     if (!doc) {
         qCDebug(PLUGIN_QUICKOPEN) << "No active document";
         return;
     }
 
     KDevelop::DUChainReadLocker lock(DUChain::lock());
 
     TopDUContext* context = DUChainUtils::standardContextForUrl(doc->url());
 
     if (!context) {
         qCDebug(PLUGIN_QUICKOPEN) << "Got no standard context";
         return;
     }
 
     QVector<DUChainItem> items;
     OutlineFilter filter(items, OutlineFilter::Functions);
     DUChainUtils::collectItems(context, filter);
 
     CursorInRevision cursor = context->transformToLocalRevision(KTextEditor::Cursor(doc->cursorPosition()));
     if (!cursor.isValid()) {
         return;
     }
 
     Declaration* nearestDeclBefore = nullptr;
     int distanceBefore = INT_MIN;
     Declaration* nearestDeclAfter = nullptr;
     int distanceAfter = INT_MAX;
 
     for (int i = 0; i < items.count(); ++i) {
         Declaration* decl = items[i].m_item.data();
 
         int distance = decl->range().start.line - cursor.line;
         if (distance < 0 && distance >= distanceBefore) {
             distanceBefore = distance;
             nearestDeclBefore = decl;
         } else if (distance > 0 && distance <= distanceAfter) {
             distanceAfter = distance;
             nearestDeclAfter = decl;
         }
     }
 
     CursorInRevision c = CursorInRevision::invalid();
     if (direction == QuickOpenPlugin::NextFunction && nearestDeclAfter) {
         c = nearestDeclAfter->range().start;
     } else if (direction == QuickOpenPlugin::PreviousFunction && nearestDeclBefore) {
         c = nearestDeclBefore->range().start;
     }
 
     KTextEditor::Cursor textCursor = KTextEditor::Cursor::invalid();
     if (c.isValid()) {
         textCursor = context->transformFromLocalRevision(c);
     }
 
     lock.unlock();
     if (textCursor.isValid()) {
         core()->documentController()->openDocument(doc->url(), textCursor);
     } else {
         qCDebug(PLUGIN_QUICKOPEN) << "No declaration to jump to";
     }
 }
 
 struct CreateOutlineDialog
 {
     CreateOutlineDialog() : dialog(nullptr)
         , cursorDecl(nullptr)
         , model(nullptr)
     {
     }
 
     void start()
     {
         if (!QuickOpenPlugin::self()->freeModel()) {
             return;
         }
 
         IDocument* doc = ICore::self()->documentController()->activeDocument();
         if (!doc) {
             qCDebug(PLUGIN_QUICKOPEN) << "No active document";
             return;
         }
 
         KDevelop::DUChainReadLocker lock(DUChain::lock());
 
         TopDUContext* context = DUChainUtils::standardContextForUrl(doc->url());
 
         if (!context) {
             qCDebug(PLUGIN_QUICKOPEN) << "Got no standard context";
             return;
         }
 
         model = new QuickOpenModel(nullptr);
 
         OutlineFilter filter(items);
 
         DUChainUtils::collectItems(context, filter);
 
         if (noHtmlDestriptionInOutline) {
             for (int a = 0; a < items.size(); ++a) {
                 items[a].m_noHtmlDestription = true;
             }
         }
 
         cursorDecl = cursorContextDeclaration();
 
         model->registerProvider(QStringList(), QStringList(), new DeclarationListDataProvider(QuickOpenPlugin::self(), items, true));
 
         dialog = new QuickOpenWidgetDialog(i18n("Outline"), model, QStringList(), QStringList(), true);
         dialog->widget()->setSortingEnabled(true);
 
         model->setParent(dialog->widget());
     }
     void finish()
     {
         //Select the declaration that contains the cursor
         if (cursorDecl && dialog) {
             int num = 0;
             foreach (const DUChainItem& item, items) {
                 if (item.m_item.data() == cursorDecl) {
                     QModelIndex index(model->index(num, 0, QModelIndex()));
                     // Need to invoke the scrolling later. If we did it now, then it wouldn't have any effect,
                     // apparently because the widget internals aren't initialized yet properly (although we've
                     // already called 'widget->show()'.
                     auto list = dialog->widget()->ui.list;
                     QMetaObject::invokeMethod(list, "setCurrentIndex", Qt::QueuedConnection, Q_ARG(QModelIndex, index));
                     QMetaObject::invokeMethod(list, "scrollTo", Qt::QueuedConnection, Q_ARG(QModelIndex, index), Q_ARG(QAbstractItemView::ScrollHint, QAbstractItemView::PositionAtCenter));
                 }
                 ++num;
             }
         }
     }
     QPointer<QuickOpenWidgetDialog> dialog;
     Declaration* cursorDecl;
     QVector<DUChainItem> items;
     QuickOpenModel* model;
 };
 
 class OutlineQuickopenWidgetCreator
     : public QuickOpenWidgetCreator
 {
 public:
     OutlineQuickopenWidgetCreator(const QStringList& /*scopes*/, const QStringList& /*items*/) : m_creator(nullptr)
     {
     }
 
     ~OutlineQuickopenWidgetCreator() override
     {
         delete m_creator;
     }
 
     QuickOpenWidget* createWidget() override
     {
         delete m_creator;
         m_creator = new CreateOutlineDialog;
         m_creator->start();
 
         if (!m_creator->dialog) {
             return nullptr;
         }
 
         m_creator->dialog->deleteLater();
         return m_creator->dialog->widget();
     }
 
     void widgetShown() override
     {
         if (m_creator) {
             m_creator->finish();
             delete m_creator;
             m_creator = nullptr;
         }
     }
 
     QString objectNameForLine() override
     {
         return QStringLiteral("Outline");
     }
 
     CreateOutlineDialog* m_creator;
 };
 
 void QuickOpenPlugin::quickOpenNavigateFunctions()
 {
     CreateOutlineDialog create;
     create.start();
 
     if (!create.dialog) {
         return;
     }
 
     m_currentWidgetHandler = create.dialog;
 
     QuickOpenLineEdit* line = quickOpenLine(QStringLiteral("Outline"));
     if (!line) {
         line  = quickOpenLine();
     }
 
     if (line) {
         line->showWithWidget(create.dialog->widget());
         create.dialog->deleteLater();
     } else {
         create.dialog->run();
     }
 
     create.finish();
 }
 
 QuickOpenLineEdit::QuickOpenLineEdit(QuickOpenWidgetCreator* creator) : m_widget(nullptr)
     , m_forceUpdate(false)
     , m_widgetCreator(creator)
 {
     setFont(qApp->font("QToolButton"));
     setMinimumWidth(200);
     setMaximumWidth(400);
 
     deactivate();
     setDefaultText(i18n("Quick Open..."));
     setToolTip(i18n("Search for files, classes, functions and more,"
                     " allowing you to quickly navigate in your source code."));
     setObjectName(m_widgetCreator->objectNameForLine());
     setFocusPolicy(Qt::ClickFocus);
 }
 
 QuickOpenLineEdit::~QuickOpenLineEdit()
 {
     delete m_widget;
     delete m_widgetCreator;
 }
 
 bool QuickOpenLineEdit::insideThis(QObject* object)
 {
     while (object) {
         qCDebug(PLUGIN_QUICKOPEN) << object;
         if (object == this || object == m_widget) {
             return true;
         }
         object = object->parent();
     }
     return false;
 }
 
 void QuickOpenLineEdit::widgetDestroyed(QObject* obj)
 {
     Q_UNUSED(obj);
     // need to use a queued connection here, because this function is called in ~QWidget!
     // => QuickOpenWidget instance is half-destructed => connections are not yet cleared
     // => clear() will trigger signals which will operate on the invalid QuickOpenWidget
     // So, just wait until properly destructed
     QMetaObject::invokeMethod(this, "deactivate", Qt::QueuedConnection);
 }
 
 void QuickOpenLineEdit::showWithWidget(QuickOpenWidget* widget)
 {
     connect(widget, &QuickOpenWidget::destroyed, this, &QuickOpenLineEdit::widgetDestroyed);
     qCDebug(PLUGIN_QUICKOPEN) << "storing widget" << widget;
     deactivate();
     if (m_widget) {
         qCDebug(PLUGIN_QUICKOPEN) << "deleting" << m_widget;
         delete m_widget;
     }
     m_widget = widget;
     m_forceUpdate = true;
     setFocus();
 }
 
 void QuickOpenLineEdit::focusInEvent(QFocusEvent* ev)
 {
     QLineEdit::focusInEvent(ev);
 //       delete m_widget;
     qCDebug(PLUGIN_QUICKOPEN) << "got focus";
     qCDebug(PLUGIN_QUICKOPEN) << "old widget" << m_widget << "force update:" << m_forceUpdate;
     if (m_widget && !m_forceUpdate) {
         return;
     }
 
     if (!m_forceUpdate && !QuickOpenPlugin::self()->freeModel()) {
         deactivate();
         return;
     }
 
     m_forceUpdate = false;
 
     if (!m_widget) {
         m_widget = m_widgetCreator->createWidget();
         if (!m_widget) {
             deactivate();
             return;
         }
     }
 
     activate();
 
     m_widget->showStandardButtons(false);
     m_widget->showSearchField(false);
 
     m_widget->setParent(nullptr, Qt::ToolTip);
     m_widget->setFocusPolicy(Qt::NoFocus);
     m_widget->setAlternativeSearchField(this);
 
     QuickOpenPlugin::self()->m_currentWidgetHandler = m_widget;
     connect(m_widget.data(), &QuickOpenWidget::ready, this, &QuickOpenLineEdit::deactivate);
 
     connect(m_widget.data(), &QuickOpenWidget::scopesChanged, QuickOpenPlugin::self(), &QuickOpenPlugin::storeScopes);
     connect(m_widget.data(), &QuickOpenWidget::itemsChanged, QuickOpenPlugin::self(), &QuickOpenPlugin::storeItems);
     Q_ASSERT(m_widget->ui.searchLine == this);
     m_widget->prepareShow();
     QRect widgetGeometry = QRect(mapToGlobal(QPoint(0, height())), mapToGlobal(QPoint(width(), height() + 400)));
     widgetGeometry.setWidth(700); ///@todo Waste less space
     QRect screenGeom = QApplication::desktop()->screenGeometry(this);
     if (widgetGeometry.right() > screenGeom.right()) {
         widgetGeometry.moveRight(screenGeom.right());
     }
     if (widgetGeometry.bottom() > screenGeom.bottom()) {
         widgetGeometry.moveBottom(mapToGlobal(QPoint(0, 0)).y());
     }
     m_widget->setGeometry(widgetGeometry);
     m_widget->show();
 
     m_widgetCreator->widgetShown();
 }
 
 void QuickOpenLineEdit::hideEvent(QHideEvent* ev)
 {
     QWidget::hideEvent(ev);
     if (m_widget) {
         QMetaObject::invokeMethod(this, "checkFocus", Qt::QueuedConnection);
     }
 //       deactivate();
 }
 
 bool QuickOpenLineEdit::eventFilter(QObject* obj, QEvent* e)
 {
     if (!m_widget) {
         return IQuickOpenLine::eventFilter(obj, e);
     }
 
     switch (e->type()) {
     case QEvent::KeyPress:
     case QEvent::ShortcutOverride:
         if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape) {
             deactivate();
             e->accept();
             return true; // eat event
         }
         break;
     case QEvent::WindowActivate:
     case QEvent::WindowDeactivate:
         QMetaObject::invokeMethod(this, "checkFocus", Qt::QueuedConnection);
         break;
     // handle bug 260657 - "Outline menu doesn't follow main window on its move"
     case QEvent::Move: {
         if (QWidget* widget = qobject_cast<QWidget*>(obj)) {
             // close the outline menu in case a parent widget moved
             if (widget->isAncestorOf(this)) {
                 qCDebug(PLUGIN_QUICKOPEN) << "closing because of parent widget move";
                 deactivate();
             }
         }
         break;
     }
     case QEvent::FocusIn:
         if (dynamic_cast<QWidget*>(obj)) {
             QFocusEvent* focusEvent = dynamic_cast<QFocusEvent*>(e);
             Q_ASSERT(focusEvent);
             //Eat the focus event, keep the focus
             qCDebug(PLUGIN_QUICKOPEN) << "focus change" << "inside this: " << insideThis(obj) << "this" << this << "obj" << obj;
             if (obj == this) {
                 break;
             }
 
             qCDebug(PLUGIN_QUICKOPEN) << "reason" << focusEvent->reason();
             if (focusEvent->reason() != Qt::MouseFocusReason && focusEvent->reason() != Qt::ActiveWindowFocusReason) {
                 QMetaObject::invokeMethod(this, "checkFocus", Qt::QueuedConnection);
                 break;
             }
             if (!insideThis(obj)) {
                 deactivate();
             }
         } else if (obj != this) {
             QMetaObject::invokeMethod(this, "checkFocus", Qt::QueuedConnection);
         }
         break;
     default:
         break;
     }
 
     return IQuickOpenLine::eventFilter(obj, e);
 }
 void QuickOpenLineEdit::activate()
 {
     qCDebug(PLUGIN_QUICKOPEN) << "activating";
     setText(QString());
     setStyleSheet(QString());
     qApp->installEventFilter(this);
 }
 void QuickOpenLineEdit::deactivate()
 {
     qCDebug(PLUGIN_QUICKOPEN) << "deactivating";
 
     clear();
 
     if (m_widget || hasFocus()) {
         QMetaObject::invokeMethod(this, "checkFocus", Qt::QueuedConnection);
     }
 
     if (m_widget) {
         m_widget->deleteLater();
     }
 
     m_widget = nullptr;
     qApp->removeEventFilter(this);
 }
 
 void QuickOpenLineEdit::checkFocus()
 {
     qCDebug(PLUGIN_QUICKOPEN) << "checking focus" << m_widget;
     if (m_widget) {
         QWidget* focusWidget = QApplication::focusWidget();
         bool focusWidgetInsideThis = focusWidget ? insideThis(focusWidget) : false;
         if (QApplication::focusWindow() && isVisible() && !isHidden() && (!focusWidget || (focusWidget && focusWidgetInsideThis))) {
             qCDebug(PLUGIN_QUICKOPEN) << "setting focus to line edit";
             activateWindow();
             setFocus();
         } else {
             qCDebug(PLUGIN_QUICKOPEN) << "deactivating because check failed, focusWidget" << focusWidget << "insideThis" << focusWidgetInsideThis;
             deactivate();
         }
     } else {
         if (ICore::self()->documentController()->activeDocument()) {
             ICore::self()->documentController()->activateDocument(ICore::self()->documentController()->activeDocument());
         }
 
         //Make sure the focus is somewehre else, even if there is no active document
         setEnabled(false);
         setEnabled(true);
     }
 }
 
 IQuickOpenLine* QuickOpenPlugin::createQuickOpenLine(const QStringList& scopes, const QStringList& type, IQuickOpen::QuickOpenType kind)
 {
     if (kind == Outline) {
         return new QuickOpenLineEdit(new OutlineQuickopenWidgetCreator(scopes, type));
     } else {
         return new QuickOpenLineEdit(new StandardQuickOpenWidgetCreator(scopes, type));
     }
 }
 
 #include "quickopenplugin.moc"