diff --git a/plugins/problemreporter/problemsview.cpp b/plugins/problemreporter/problemsview.cpp
index 277cf0a115..e08b256d99 100644
--- a/plugins/problemreporter/problemsview.cpp
+++ b/plugins/problemreporter/problemsview.cpp
@@ -1,456 +1,514 @@
 /*
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * 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 "problemsview.h"
 
 #include <KActionMenu>
 #include <KLocalizedString>
 
 #include <QAction>
+#include <QLineEdit>
 #include <QMenu>
 #include <QSignalMapper>
 #include <QTabWidget>
+#include <QTimer>
 #include <QVBoxLayout>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <shell/problemconstants.h>
 #include <shell/problemmodelset.h>
 #include "problemtreeview.h"
 #include "problemmodel.h"
 
 namespace KDevelop
 {
 
 void ProblemsView::setupActions()
 {
     {
         m_fullUpdateAction = new QAction(this);
         m_fullUpdateAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         m_fullUpdateAction->setText(i18n("Force Full Update"));
         m_fullUpdateAction->setToolTip(i18nc("@info:tooltip", "Re-parse all watched documents"));
         m_fullUpdateAction->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
         connect(m_fullUpdateAction, &QAction::triggered, this, [this]() {
             currentView()->model()->forceFullUpdate();
         });
         addAction(m_fullUpdateAction);
     }
 
     {
         m_showImportsAction = new QAction(this);
         addAction(m_showImportsAction);
         m_showImportsAction->setCheckable(true);
         m_showImportsAction->setChecked(false);
         m_showImportsAction->setText(i18n("Show Imports"));
         m_showImportsAction->setToolTip(i18nc("@info:tooltip", "Display problems in imported files"));
         connect(m_showImportsAction, &QAction::triggered, this, [this](bool checked) {
             currentView()->model()->setShowImports(checked);
         });
     }
 
     {
         m_scopeMenu = new KActionMenu(this);
         m_scopeMenu->setDelayed(false);
         m_scopeMenu->setToolTip(i18nc("@info:tooltip", "Which files to display the problems for"));
         m_scopeMenu->setObjectName(QStringLiteral("scopeMenu"));
 
         QActionGroup* scopeActions = new QActionGroup(this);
 
         m_currentDocumentAction = new QAction(this);
         m_currentDocumentAction->setText(i18n("Current Document"));
         m_currentDocumentAction->setToolTip(i18nc("@info:tooltip", "Display problems in current document"));
 
         QAction* openDocumentsAction = new QAction(this);
         openDocumentsAction->setText(i18n("Open Documents"));
         openDocumentsAction->setToolTip(i18nc("@info:tooltip", "Display problems in all open documents"));
 
         QAction* currentProjectAction = new QAction(this);
         currentProjectAction->setText(i18n("Current Project"));
         currentProjectAction->setToolTip(i18nc("@info:tooltip", "Display problems in current project"));
 
         QAction* allProjectAction = new QAction(this);
         allProjectAction->setText(i18n("All Projects"));
         allProjectAction->setToolTip(i18nc("@info:tooltip", "Display problems in all projects"));
 
         QVector<QAction*> actions;
         actions.push_back(m_currentDocumentAction);
         actions.push_back(openDocumentsAction);
         actions.push_back(currentProjectAction);
         actions.push_back(allProjectAction);
 
         m_showAllAction = new QAction(this);
         m_showAllAction->setText(i18n("Show All"));
         m_showAllAction->setToolTip(i18nc("@info:tooltip", "Display ALL problems"));
         actions.push_back(m_showAllAction);
 
         foreach (QAction* action, actions) {
             action->setCheckable(true);
             scopeActions->addAction(action);
             m_scopeMenu->addAction(action);
         }
         addAction(m_scopeMenu);
 
         QSignalMapper* scopeMapper = new QSignalMapper(this);
         scopeMapper->setMapping(m_currentDocumentAction, CurrentDocument);
         scopeMapper->setMapping(openDocumentsAction, OpenDocuments);
         scopeMapper->setMapping(currentProjectAction, CurrentProject);
         scopeMapper->setMapping(allProjectAction, AllProjects);
         connect(m_currentDocumentAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(openDocumentsAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(currentProjectAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(allProjectAction, &QAction::triggered, scopeMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
 
         {
             scopeMapper->setMapping(actions.last(), BypassScopeFilter);
             connect(actions.last(), &QAction::triggered, scopeMapper,
                     static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         }
 
         connect(scopeMapper, static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped),
                 this, [this](int index) {
             setScope(index);
         });
     }
 
     {
         m_severityActions = new QActionGroup(this);
 
         m_errorSeverityAction = new QAction(this);
         m_errorSeverityAction->setToolTip(i18nc("@info:tooltip", "Display errors"));
         m_errorSeverityAction->setIcon(QIcon::fromTheme(QStringLiteral("dialog-error")));
 
         m_warningSeverityAction = new QAction(this);
         m_warningSeverityAction->setToolTip(i18nc("@info:tooltip", "Display warnings"));
         m_warningSeverityAction->setIcon(QIcon::fromTheme(QStringLiteral("dialog-warning")));
 
         m_hintSeverityAction = new QAction(this);
         m_hintSeverityAction->setToolTip(i18nc("@info:tooltip", "Display hints"));
         m_hintSeverityAction->setIcon(QIcon::fromTheme(QStringLiteral("dialog-information")));
 
         QAction* severityActionArray[] = { m_errorSeverityAction, m_warningSeverityAction, m_hintSeverityAction };
         for (int i = 0; i < 3; ++i) {
             severityActionArray[i]->setCheckable(true);
             m_severityActions->addAction(severityActionArray[i]);
             addAction(severityActionArray[i]);
         }
         m_severityActions->setExclusive(false);
 
         m_hintSeverityAction->setChecked(true);
         m_warningSeverityAction->setChecked(true);
         m_errorSeverityAction->setChecked(true);
 
         connect(m_errorSeverityAction, &QAction::toggled, this, &ProblemsView::handleSeverityActionToggled);
         connect(m_warningSeverityAction, &QAction::toggled, this, &ProblemsView::handleSeverityActionToggled);
         connect(m_hintSeverityAction, &QAction::toggled, this, &ProblemsView::handleSeverityActionToggled);
     }
 
     {
         m_groupingMenu = new KActionMenu(i18n("Grouping"), this);
         m_groupingMenu->setDelayed(false);
 
         QActionGroup* groupingActions = new QActionGroup(this);
 
         QAction* noGroupingAction = new QAction(i18n("None"), this);
         QAction* pathGroupingAction = new QAction(i18n("Path"), this);
         QAction* severityGroupingAction = new QAction(i18n("Severity"), this);
 
         QAction* groupingActionArray[] = { noGroupingAction, pathGroupingAction, severityGroupingAction };
         for (unsigned i = 0; i < sizeof(groupingActionArray) / sizeof(QAction*); ++i) {
             QAction* action = groupingActionArray[i];
             action->setCheckable(true);
             groupingActions->addAction(action);
             m_groupingMenu->addAction(action);
         }
         addAction(m_groupingMenu);
 
         noGroupingAction->setChecked(true);
         QSignalMapper* groupingMapper = new QSignalMapper(this);
         groupingMapper->setMapping(noGroupingAction, NoGrouping);
         groupingMapper->setMapping(pathGroupingAction, PathGrouping);
         groupingMapper->setMapping(severityGroupingAction, SeverityGrouping);
 
         connect(noGroupingAction, &QAction::triggered, groupingMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(pathGroupingAction, &QAction::triggered, groupingMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(severityGroupingAction, &QAction::triggered, groupingMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
 
         connect(groupingMapper, static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped),
                 this, [this](int index) {
             currentView()->model()->setGrouping(index);
         });
     }
+
+    {
+        QTimer* filterTimer = new QTimer(this);
+        filterTimer->setSingleShot(true);
+
+        connect(filterTimer, &QTimer::timeout, this, [this]() {
+            setFilter(m_filterEdit->text());
+        });
+
+        m_filterEdit = new QLineEdit(this);
+        m_filterEdit->setClearButtonEnabled(true);
+        m_filterEdit->setPlaceholderText(i18n("Search..."));
+
+        QSizePolicy p(m_filterEdit->sizePolicy());
+        p.setHorizontalPolicy(QSizePolicy::Fixed);
+        m_filterEdit->setSizePolicy(p);
+
+        connect(m_filterEdit, &QLineEdit::textChanged, this, [filterTimer](const QString&) {
+            filterTimer->start(500);
+        });
+
+        QWidgetAction* filterAction = new QWidgetAction(this);
+        filterAction->setDefaultWidget(m_filterEdit);
+        addAction(filterAction);
+
+        m_prevTabIdx = -1;
+        setFocusProxy(m_filterEdit);
+    }
 }
 
 void ProblemsView::updateActions()
 {
     auto problemModel = currentView()->model();
     Q_ASSERT(problemModel);
 
     m_fullUpdateAction->setVisible(problemModel->features().testFlag(ProblemModel::CanDoFullUpdate));
     m_showImportsAction->setVisible(problemModel->features().testFlag(ProblemModel::CanShowImports));
     m_scopeMenu->setVisible(problemModel->features().testFlag(ProblemModel::ScopeFilter));
     m_severityActions->setVisible(problemModel->features().testFlag(ProblemModel::SeverityFilter));
     m_groupingMenu->setVisible(problemModel->features().testFlag(ProblemModel::Grouping));
 
     m_showAllAction->setVisible(problemModel->features().testFlag(ProblemModel::CanByPassScopeFilter));
 
     problemModel->setShowImports(false);
     setScope(CurrentDocument);
 
     // Show All should be default if it's supported. It helps with error messages that are otherwise invisible
     if (problemModel->features().testFlag(ProblemModel::CanByPassScopeFilter)) {
         //actions.last()->setChecked(true);
         setScope(BypassScopeFilter);
     } else {
         m_currentDocumentAction->setChecked(true);
         setScope(CurrentDocument);
     }
 
     problemModel->setSeverities(IProblem::Error | IProblem::Warning | IProblem::Hint);
+
+    setFocus(); // set focus to default widget (filterEdit)
 }
 
 /// TODO: Move to util?
 /// Note: Support for recursing into child indices would be nice
 class ItemViewWalker
 {
 public:
     ItemViewWalker(QItemSelectionModel* itemView);
 
     void selectNextIndex();
     void selectPreviousIndex();
 
     enum Direction { NextIndex, PreviousIndex };
     void selectIndex(Direction direction);
 
 private:
     QItemSelectionModel* m_selectionModel;
 };
 
 ItemViewWalker::ItemViewWalker(QItemSelectionModel* itemView)
     : m_selectionModel(itemView)
 {
 }
 
 void ItemViewWalker::selectNextIndex()
 {
     selectIndex(NextIndex);
 }
 
 void ItemViewWalker::selectPreviousIndex()
 {
     selectIndex(PreviousIndex);
 }
 
 void ItemViewWalker::selectIndex(Direction direction)
 {
     if (!m_selectionModel) {
         return;
     }
 
     const QModelIndexList list = m_selectionModel->selectedRows();
 
     const QModelIndex currentIndex = list.value(0);
     if (!currentIndex.isValid()) {
         /// no selection yet, just select the first
         const QModelIndex firstIndex = m_selectionModel->model()->index(0, 0);
         m_selectionModel->setCurrentIndex(firstIndex, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
         return;
     }
 
     const int nextRow = currentIndex.row() + (direction == NextIndex ? 1 : -1);
     const QModelIndex nextIndex = currentIndex.sibling(nextRow, 0);
     if (!nextIndex.isValid()) {
         return; /// never invalidate the selection
     }
 
     m_selectionModel->setCurrentIndex(nextIndex, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
 }
 
 ProblemsView::ProblemsView(QWidget* parent)
     : QWidget(parent)
 {
     setWindowTitle(i18n("Problems"));
     setWindowIcon(QIcon::fromTheme(QStringLiteral("script-error"), windowIcon()));
 
     auto layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
 
     m_tabWidget = new QTabWidget(this);
     m_tabWidget->setTabPosition(QTabWidget::South);
     layout->addWidget(m_tabWidget);
 
     setupActions();
 }
 
 ProblemsView::~ProblemsView()
 {
 }
 
 void ProblemsView::load()
 {
     m_tabWidget->clear();
 
     KDevelop::ProblemModelSet* pms = KDevelop::ICore::self()->languageController()->problemModelSet();
     QVector<KDevelop::ModelData> v = pms->models();
 
     QVectorIterator<KDevelop::ModelData> itr(v);
     while (itr.hasNext()) {
         const KDevelop::ModelData& data = itr.next();
         addModel(data);
     }
 
     connect(pms, &ProblemModelSet::added, this, &ProblemsView::onModelAdded);
     connect(pms, &ProblemModelSet::removed, this, &ProblemsView::onModelRemoved);
     connect(m_tabWidget, &QTabWidget::currentChanged, this, &ProblemsView::onCurrentChanged);
 
     if (m_tabWidget->currentIndex() == 0) {
         updateActions();
         return;
     }
 
     m_tabWidget->setCurrentIndex(0);
 }
 
 void ProblemsView::onModelAdded(const ModelData& data)
 {
     addModel(data);
 }
 
 /**
  * @brief Returns the name part of the label
  *
  * E.g.: Test (666) => Test
  */
 QString nameFromLabel(const QString& label)
 {
     QString txt = label;
     int i = txt.lastIndexOf('(');
     if (i != -1)
         txt = txt.left(i - 1); /// ignore whitespace before '('
     return txt;
 }
 
 int tabIndexForName(const QTabWidget* tabWidget, const QString& name)
 {
     for (int idx = 0; idx < tabWidget->count(); ++idx) {
         if (nameFromLabel(tabWidget->tabText(idx)) == name) {
             return idx;
         }
     }
 
     return -1;
 }
 
 void ProblemsView::showModel(const QString& name)
 {
     int idx = tabIndexForName(m_tabWidget, name);
     if (idx >= 0)
         m_tabWidget->setCurrentIndex(idx);
 }
 
 void ProblemsView::onModelRemoved(const QString& name)
 {
     int idx = tabIndexForName(m_tabWidget, name);
     if (idx >= 0) {
         QWidget* w = m_tabWidget->widget(idx);
         m_tabWidget->removeTab(idx);
         delete w;
     }
 }
 
 void ProblemsView::onCurrentChanged(int idx)
 {
     if (idx == -1)
         return;
 
+    setFilter(QStringLiteral(""), m_prevTabIdx);
+    setFilter(QStringLiteral(""));
+    m_prevTabIdx = idx;
+
     updateActions();
 }
 
 void ProblemsView::onViewChanged()
 {
     ProblemTreeView* view = static_cast<ProblemTreeView*>(sender());
     int idx = m_tabWidget->indexOf(view);
     int rows = view->model()->rowCount();
 
     updateTab(idx, rows);
 }
 
 void ProblemsView::addModel(const ModelData& data)
 {
     ProblemTreeView* view = new ProblemTreeView(nullptr, data.model);
     connect(view, &ProblemTreeView::changed, this, &ProblemsView::onViewChanged);
     int idx = m_tabWidget->addTab(view, data.name);
     int rows = view->model()->rowCount();
 
     updateTab(idx, rows);
 }
 
 void ProblemsView::updateTab(int idx, int rows)
 {
     const QString name = nameFromLabel(m_tabWidget->tabText(idx));
     const QString tabText = i18nc("%1: tab name, %2: number of problems", "%1 (%2)", name, rows);
     m_tabWidget->setTabText(idx, tabText);
 }
 
 ProblemTreeView* ProblemsView::currentView() const
 {
     return qobject_cast<ProblemTreeView*>(m_tabWidget->currentWidget());
 }
 
 void ProblemsView::selectNextItem()
 {
     auto view = currentView();
     if (view) {
         ItemViewWalker walker(view->selectionModel());
         walker.selectNextIndex();
         view->openDocumentForCurrentProblem();
     }
 }
 
 void ProblemsView::selectPreviousItem()
 {
     auto view = currentView();
     if (view) {
         ItemViewWalker walker(view->selectionModel());
         walker.selectPreviousIndex();
         view->openDocumentForCurrentProblem();
     }
 }
 
 void ProblemsView::handleSeverityActionToggled()
 {
     currentView()->model()->setSeverities( (m_errorSeverityAction->isChecked() ? IProblem::Error : IProblem::Severities()) |
                             (m_warningSeverityAction->isChecked() ? IProblem::Warning : IProblem::Severities()) |
                             (m_hintSeverityAction->isChecked() ? IProblem::Hint : IProblem::Severities()) );
 }
 
 void ProblemsView::setScope(int scope)
 {
     m_scopeMenu->setText(i18n("Scope: %1", m_scopeMenu->menu()->actions().at(scope)->text()));
 
     currentView()->model()->setScope(scope);
 }
 
+void ProblemsView::setFilter(const QString& filterText)
+{
+    setFilter(filterText, m_tabWidget->currentIndex());
+}
+
+void ProblemsView::setFilter(const QString& filterText, int tabIdx)
+{
+    if (tabIdx < 0 || tabIdx >= m_tabWidget->count())
+        return;
+
+    ProblemTreeView* view = static_cast<ProblemTreeView*>(m_tabWidget->widget(tabIdx));
+    int rows = view->setFilter(filterText);
+
+    updateTab(tabIdx, rows);
+
+    if (tabIdx == m_tabWidget->currentIndex()) {
+        m_filterEdit->blockSignals(true);
+        m_filterEdit->setText(filterText);
+        m_filterEdit->blockSignals(false);
+    }
+}
+
 }
diff --git a/plugins/problemreporter/problemsview.h b/plugins/problemreporter/problemsview.h
index 72eb595398..cd72f52fbe 100644
--- a/plugins/problemreporter/problemsview.h
+++ b/plugins/problemreporter/problemsview.h
@@ -1,110 +1,117 @@
 /*
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * 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 PROBLEMSVIEW_H
 #define PROBLEMSVIEW_H
 
 #include <interfaces/itoolviewactionlistener.h>
 
 #include <QWidget>
 
 class ProblemTreeView;
 
 class KActionMenu;
 
 class QAction;
 class QActionGroup;
+class QLineEdit;
 class QMenu;
 class QTabWidget;
 
 namespace KDevelop
 {
 struct ModelData;
 
 /**
  * @brief Provides a tabbed view for models in the ProblemModelSet.
  *
  *
  * Also provides a toolbar for actions for the models and shows the number of messages in each tab's text.
  * When the load() method is called it looks up the models in the ProblemModelSet.
  * For each model it creates a treeview, which is then added to the tabbed view and a new tab.
  * The tab's text will be the name of the model + the number of items in the treeview.
  */
 class ProblemsView : public QWidget, public IToolViewActionListener
 {
     Q_OBJECT
     Q_INTERFACES(KDevelop::IToolViewActionListener)
 
 public:
     explicit ProblemsView(QWidget* parent = nullptr);
     ~ProblemsView() override;
 
     /// Load all the current models and create tabs for them
     void load();
 
 public Q_SLOTS:
     /// Triggered when a new model is added to the ModelSet
     void onModelAdded(const ModelData& data);
 
     /// Triggered when a model is removed from the ModelSet
     void onModelRemoved(const QString& name);
 
     /// Triggered when the user (or program) selects a new tab
     void onCurrentChanged(int idx);
 
     /// Triggered when a view changes (happens when the model data changes)
     void onViewChanged();
 
     /// Open tab for selected model
     void showModel(const QString& name);
 
     void selectNextItem() override;
     void selectPreviousItem() override;
 
 private:
     ProblemTreeView* currentView() const;
 
     void setupActions();
     void updateActions();
 
     void handleSeverityActionToggled();
     void setScope(int scope);
 
     /// Create a view for the model and add to the tabbed widget
     void addModel(const ModelData& data);
 
     /// Update the tab's text (name + number of problems in that tab)
     void updateTab(int idx, int rows);
 
     QTabWidget* m_tabWidget;
 
     KActionMenu* m_scopeMenu = nullptr;
     KActionMenu* m_groupingMenu = nullptr;
     QAction* m_fullUpdateAction = nullptr;
     QAction* m_showImportsAction = nullptr;
     QActionGroup* m_severityActions = nullptr;
     QAction* m_currentDocumentAction = nullptr;
     QAction* m_showAllAction = nullptr;
     QAction* m_errorSeverityAction = nullptr;
     QAction* m_warningSeverityAction = nullptr;
     QAction* m_hintSeverityAction = nullptr;
+
+    void setFilter(const QString& filterText);
+    void setFilter(const QString& filterText, int tabIdx);
+
+    QLineEdit* m_filterEdit;
+    int m_prevTabIdx;
 };
 }
 
 #endif
diff --git a/plugins/problemreporter/problemtreeview.cpp b/plugins/problemreporter/problemtreeview.cpp
index 5575689cd5..eb1549e262 100644
--- a/plugins/problemreporter/problemtreeview.cpp
+++ b/plugins/problemreporter/problemtreeview.cpp
@@ -1,208 +1,218 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright (c) 2006-2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2006 Adam Treat <treat@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU 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 "problemtreeview.h"
 
 #include <QAction>
 #include <QContextMenuEvent>
 #include <QHeaderView>
 #include <QIcon>
 #include <QItemDelegate>
 #include <QMenu>
 #include <QSortFilterProxyModel>
 
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iassistant.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <util/kdevstringhandler.h>
 
 #include "problemreporterplugin.h"
 #include <shell/problemmodel.h>
 #include <shell/problem.h>
 #include <shell/problemconstants.h>
 
 //#include "modeltest.h"
 
 using namespace KDevelop;
 
 namespace KDevelop
 {
 
 class ProblemTreeViewItemDelegate : public QItemDelegate
 {
     Q_OBJECT
 
 public:
     explicit ProblemTreeViewItemDelegate(QObject* parent = nullptr);
 
     void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 };
 }
 
 ProblemTreeViewItemDelegate::ProblemTreeViewItemDelegate(QObject* parent)
     : QItemDelegate(parent)
 {
 }
 
 void ProblemTreeViewItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
                                         const QModelIndex& index) const
 {
     QStyleOptionViewItem newOption(option);
     newOption.textElideMode = index.column() == ProblemModel::File ? Qt::ElideMiddle : Qt::ElideRight;
 
     QItemDelegate::paint(painter, newOption, index);
 }
 
 ProblemTreeView::ProblemTreeView(QWidget* parent, QAbstractItemModel* itemModel)
     : QTreeView(parent)
     , m_proxy(new QSortFilterProxyModel(this))
 {
     setObjectName(QStringLiteral("Problem Reporter Tree"));
     setWhatsThis(i18n("Problems"));
     setItemDelegate(new ProblemTreeViewItemDelegate(this));
     setSelectionBehavior(QAbstractItemView::SelectRows);
 
     m_proxy->setSortRole(ProblemModel::SeverityRole);
     m_proxy->setDynamicSortFilter(true);
     m_proxy->sort(0, Qt::AscendingOrder);
 
     ProblemModel* problemModel = dynamic_cast<ProblemModel*>(itemModel);
     Q_ASSERT(problemModel);
     setModel(problemModel);
 
     header()->setStretchLastSection(false);
 
     connect(this, &ProblemTreeView::clicked, this, &ProblemTreeView::itemActivated);
 
     connect(model(), &QAbstractItemModel::rowsInserted, this, &ProblemTreeView::changed);
     connect(model(), &QAbstractItemModel::rowsRemoved, this, &ProblemTreeView::changed);
     connect(model(), &QAbstractItemModel::modelReset, this, &ProblemTreeView::changed);
+
+    m_proxy->setFilterKeyColumn(-1);
+    m_proxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
 }
 
 ProblemTreeView::~ProblemTreeView()
 {
 }
 
 void ProblemTreeView::openDocumentForCurrentProblem()
 {
     itemActivated(currentIndex());
 }
 
 void ProblemTreeView::itemActivated(const QModelIndex& index)
 {
     if (!index.isValid())
         return;
 
     KTextEditor::Cursor start;
     QUrl url;
 
     {
         // TODO: is this really necessary?
         DUChainReadLocker lock(DUChain::lock());
         const auto problem = index.data(ProblemModel::ProblemRole).value<IProblem::Ptr>();
         if (!problem)
             return;
 
         url = problem->finalLocation().document.toUrl();
         start = problem->finalLocation().start();
     }
 
     ICore::self()->documentController()->openDocument(url, start);
 }
 
 void ProblemTreeView::resizeColumns()
 {
     for (int i = 0; i < model()->columnCount(); ++i)
         resizeColumnToContents(i);
 }
 
 void ProblemTreeView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
 {
     QTreeView::dataChanged(topLeft, bottomRight, roles);
     resizeColumns();
 }
 
 void ProblemTreeView::reset()
 {
     QTreeView::reset();
     resizeColumns();
 }
 
+int ProblemTreeView::setFilter(const QString& filterText)
+{
+    m_proxy->setFilterFixedString(filterText);
+
+    return m_proxy->rowCount();
+}
+
 ProblemModel* ProblemTreeView::model() const
 {
     return static_cast<ProblemModel*>(m_proxy->sourceModel());
 }
 
 void ProblemTreeView::setModel(QAbstractItemModel* model)
 {
     Q_ASSERT(qobject_cast<ProblemModel*>(model));
     m_proxy->setSourceModel(model);
     QTreeView::setModel(m_proxy);
 }
 
 void ProblemTreeView::contextMenuEvent(QContextMenuEvent* event)
 {
     QModelIndex index = indexAt(event->pos());
     if (!index.isValid())
         return;
 
     const auto problem = index.data(ProblemModel::ProblemRole).value<IProblem::Ptr>();
     if (!problem) {
         return;
     }
 
     QExplicitlySharedDataPointer<KDevelop::IAssistant> solution = problem->solutionAssistant();
     if (!solution) {
         return;
     }
 
     QList<QAction*> actions;
     foreach (KDevelop::IAssistantAction::Ptr action, solution->actions()) {
         actions << action->toKAction();
     }
 
     if (actions.isEmpty()) {
         return;
     }
 
     QString title = solution->title();
     title = KDevelop::htmlToPlainText(title);
     title.replace(QLatin1String("&apos;"), QLatin1String("\'"));
 
     QPointer<QMenu> m = new QMenu(this);
     m->addSection(title);
     m->addActions(actions);
     m->exec(event->globalPos());
     delete m;
 }
 
 void ProblemTreeView::showEvent(QShowEvent* event)
 {
     Q_UNUSED(event)
     resizeColumns();
 }
 
 #include "problemtreeview.moc"
diff --git a/plugins/problemreporter/problemtreeview.h b/plugins/problemreporter/problemtreeview.h
index d6f137a7f9..331c16b424 100644
--- a/plugins/problemreporter/problemtreeview.h
+++ b/plugins/problemreporter/problemtreeview.h
@@ -1,74 +1,76 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright (c) 2007 Hamish Rodda <rodda@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU 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_PLUGIN_PROBLEMWIDGET_H
 #define KDEVPLATFORM_PLUGIN_PROBLEMWIDGET_H
 
 #include <QTreeView>
 
 namespace KDevelop
 {
 class TopDUContext;
 class IDocument;
 class ProblemModel;
 }
 
 class ProblemReporterPlugin;
 class QSortFilterProxyModel;
 
 class ProblemTreeView : public QTreeView
 {
     Q_OBJECT
 
 public:
     ProblemTreeView(QWidget* parent, QAbstractItemModel* itemModel);
     ~ProblemTreeView() override;
 
     KDevelop::ProblemModel* model() const;
     void setModel(QAbstractItemModel* model) override;
 
     void contextMenuEvent(QContextMenuEvent*) override;
     void dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight,
                              const QVector<int>& roles = QVector<int>()) override;
     void reset() override;
 
+    int setFilter(const QString& filterText);
+
 public slots:
     void openDocumentForCurrentProblem();
 
 signals:
     // Emitted when the model's rows change (added/removed/reset)
     void changed();
 
 protected:
     void showEvent(QShowEvent* event) override;
 
 private slots:
     void itemActivated(const QModelIndex& index);
 
 private:
     void resizeColumns();
     ProblemReporterPlugin* m_plugin;
     QSortFilterProxyModel* m_proxy;
 };
 
 #endif
 
 // kate: space-indent on; indent-width 2; tab-width: 4; replace-tabs on; auto-insert-doxygen on