diff --git a/outputview/outputmodel.cpp b/outputview/outputmodel.cpp
index a5f9d4eec..0dc48e628 100644
--- a/outputview/outputmodel.cpp
+++ b/outputview/outputmodel.cpp
@@ -1,468 +1,476 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                         *
  *   Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.org>                  *
  *   Copyright (C) 2012  Morten Danielsen Volden mvolden2@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 Library 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 "outputmodel.h"
 #include "filtereditem.h"
 #include "outputfilteringstrategies.h"
 #include "debug.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <util/kdevstringhandler.h>
 
 #include <QtCore/QStringList>
 #include <QtCore/QTimer>
 #include <QThread>
 #include <QFont>
 #include <QApplication>
 #include <QFontDatabase>
 
 #include <functional>
 #include <set>
 
 Q_DECLARE_METATYPE(QVector<KDevelop::FilteredItem>)
 
 namespace KDevelop
 {
 
 /**
  * Number of lines that are processed in one go before we notify the GUI thread
  * about the result. It is generally faster to add multiple items to a model
  * in one go compared to adding each item independently.
  */
 static const int BATCH_SIZE = 50;
 
 /**
  * Time in ms that we wait in the parse worker for new incoming lines before
  * actually processing them. If we already have enough for one batch though
  * we process immediately.
  */
 static const int BATCH_AGGREGATE_TIME_DELAY = 50;
 
 class ParseWorker : public QObject
 {
     Q_OBJECT
 public:
     ParseWorker()
         : QObject(nullptr)
         , m_filter(new NoFilterStrategy)
         , m_timer(new QTimer(this))
     {
         m_timer->setInterval(BATCH_AGGREGATE_TIME_DELAY);
         m_timer->setSingleShot(true);
         connect(m_timer, &QTimer::timeout, this, &ParseWorker::process);
     }
 
 public slots:
     void changeFilterStrategy( KDevelop::IFilterStrategy* newFilterStrategy )
     {
         m_filter = QSharedPointer<IFilterStrategy>( newFilterStrategy );
     }
 
     void addLines( const QStringList& lines )
     {
         m_cachedLines << lines;
 
         if (m_cachedLines.size() >= BATCH_SIZE) {
             // if enough lines were added, process immediately
             m_timer->stop();
             process();
         } else if (!m_timer->isActive()) {
             m_timer->start();
         }
     }
 
     void flushBuffers()
     {
         m_timer->stop();
         process();
         emit allDone();
     }
 
 signals:
     void parsedBatch(const QVector<KDevelop::FilteredItem>& filteredItems);
     void progress(const KDevelop::IFilterStrategy::Progress& progress);
     void allDone();
 
 private slots:
     /**
      * Process *all* cached lines, emit parsedBatch for each batch
      */
     void process()
     {
         QVector<KDevelop::FilteredItem> filteredItems;
         filteredItems.reserve(qMin(BATCH_SIZE, m_cachedLines.size()));
 
         // apply pre-filtering functions
         std::transform(m_cachedLines.constBegin(), m_cachedLines.constEnd(),
                        m_cachedLines.begin(), &KDevelop::stripAnsiSequences);
 
         // apply filtering strategy
         foreach(const QString& line, m_cachedLines) {
             FilteredItem item = m_filter->errorInLine(line);
             if( item.type == FilteredItem::InvalidItem ) {
                 item = m_filter->actionInLine(line);
             }
 
             filteredItems << item;
 
             auto progress = m_filter->progressInLine(line);
             if (progress.percent >= 0 && m_progress.percent != progress.percent) {
                 m_progress = progress;
                 emit this->progress(m_progress);
             }
 
             if( filteredItems.size() == BATCH_SIZE ) {
                 emit parsedBatch(filteredItems);
                 filteredItems.clear();
                 filteredItems.reserve(qMin(BATCH_SIZE, m_cachedLines.size()));
             }
         }
 
         // Make sure to emit the rest as well
         if( !filteredItems.isEmpty() ) {
             emit parsedBatch(filteredItems);
         }
         m_cachedLines.clear();
     }
 
 private:
     QSharedPointer<IFilterStrategy> m_filter;
     QStringList m_cachedLines;
 
     QTimer* m_timer;
     IFilterStrategy::Progress m_progress;
 };
 
 class ParsingThread
 {
 public:
     ParsingThread()
     {
         m_thread.setObjectName(QStringLiteral("OutputFilterThread"));
     }
     virtual ~ParsingThread()
     {
         if (m_thread.isRunning()) {
             m_thread.quit();
             m_thread.wait();
         }
     }
     void addWorker(ParseWorker* worker)
     {
         if (!m_thread.isRunning()) {
             m_thread.start();
         }
         worker->moveToThread(&m_thread);
     }
 private:
     QThread m_thread;
 };
 
 Q_GLOBAL_STATIC(ParsingThread, s_parsingThread);
 
 struct OutputModelPrivate
 {
     explicit OutputModelPrivate( OutputModel* model, const QUrl& builddir = QUrl() );
     ~OutputModelPrivate();
     bool isValidIndex( const QModelIndex&, int currentRowCount ) const;
 
     OutputModel* model;
     ParseWorker* worker;
 
     QVector<FilteredItem> m_filteredItems;
     // We use std::set because that is ordered
     std::set<int> m_errorItems; // Indices of all items that we want to move to using previous and next
     QUrl m_buildDir;
 
     void linesParsed(const QVector<KDevelop::FilteredItem>& items)
     {
         model->beginInsertRows( QModelIndex(), model->rowCount(), model->rowCount() + items.size() -  1);
 
         foreach( const FilteredItem& item, items ) {
             if( item.type == FilteredItem::ErrorItem ) {
                 m_errorItems.insert(m_filteredItems.size());
             }
             m_filteredItems << item;
         }
 
         model->endInsertRows();
     }
 };
 
 OutputModelPrivate::OutputModelPrivate( OutputModel* model_, const QUrl& builddir)
 : model(model_)
 , worker(new ParseWorker )
 , m_buildDir( builddir )
 {
     qRegisterMetaType<QVector<KDevelop::FilteredItem> >();
     qRegisterMetaType<KDevelop::IFilterStrategy*>();
     qRegisterMetaType<KDevelop::IFilterStrategy::Progress>();
 
     s_parsingThread->addWorker(worker);
     model->connect(worker, &ParseWorker::parsedBatch,
                    model, [=] (const QVector<KDevelop::FilteredItem>& items) { linesParsed(items); });
     model->connect(worker, &ParseWorker::allDone,
                    model, &OutputModel::allDone);
     model->connect(worker, &ParseWorker::progress,
                    model, &OutputModel::progress);
 }
 
 bool OutputModelPrivate::isValidIndex( const QModelIndex& idx, int currentRowCount ) const
 {
     return ( idx.isValid() && idx.row() >= 0 && idx.row() < currentRowCount && idx.column() == 0 );
 }
 
 OutputModelPrivate::~OutputModelPrivate()
 {
     worker->deleteLater();
 }
 
 OutputModel::OutputModel( const QUrl& builddir, QObject* parent )
 : QAbstractListModel(parent)
 , d( new OutputModelPrivate( this, builddir ) )
 {
 }
 
 OutputModel::OutputModel( QObject* parent )
     : QAbstractListModel(parent)
 , d( new OutputModelPrivate( this ) )
 {
 }
 
 OutputModel::~OutputModel()
 {
     delete d;
 }
 
 QVariant OutputModel::data(const QModelIndex& idx , int role ) const
 {
     if( d->isValidIndex(idx, rowCount()) )
     {
         switch( role )
         {
             case Qt::DisplayRole:
                 return d->m_filteredItems.at( idx.row() ).originalLine;
                 break;
             case OutputModel::OutputItemTypeRole:
                 return static_cast<int>(d->m_filteredItems.at( idx.row() ).type);
                 break;
             case Qt::FontRole:
                 return QFontDatabase::systemFont(QFontDatabase::FixedFont);
                 break;
             default:
                 break;
         }
     }
     return QVariant();
 }
 
 int OutputModel::rowCount( const QModelIndex& parent ) const
 {
     if( !parent.isValid() )
         return d->m_filteredItems.count();
     return 0;
 }
 
 QVariant OutputModel::headerData( int, Qt::Orientation, int ) const
 {
     return QVariant();
 }
 
 void OutputModel::activate( const QModelIndex& index )
 {
     if( index.model() != this || !d->isValidIndex(index, rowCount()) )
     {
         return;
     }
     qCDebug(OUTPUTVIEW) << "Model activated" << index.row();
 
 
     FilteredItem item = d->m_filteredItems.at( index.row() );
     if( item.isActivatable )
     {
         qCDebug(OUTPUTVIEW) << "activating:" << item.lineNo << item.url;
         KTextEditor::Cursor range( item.lineNo, item.columnNo );
         KDevelop::IDocumentController *docCtrl = KDevelop::ICore::self()->documentController();
         QUrl url = item.url;
         if (item.url.isEmpty()) {
             qWarning() << "trying to open empty url";
             return;
         }
         if(url.isRelative()) {
             url = d->m_buildDir.resolved(url);
         }
         Q_ASSERT(!url.isRelative());
         docCtrl->openDocument( url, range );
     } else {
         qCDebug(OUTPUTVIEW) << "not an activateable item";
     }
 }
 
 QModelIndex OutputModel::firstHighlightIndex()
 {
     if( !d->m_errorItems.empty() ) {
         return index( *d->m_errorItems.begin(), 0, QModelIndex() );
     }
 
     for( int row = 0; row < rowCount(); ++row ) {
         if( d->m_filteredItems.at( row ).isActivatable ) {
             return index( row, 0, QModelIndex() );
         }
     }
 
     return QModelIndex();
 }
 
 QModelIndex OutputModel::nextHighlightIndex( const QModelIndex &currentIdx )
 {
     int startrow = d->isValidIndex(currentIdx, rowCount()) ? currentIdx.row() + 1 : 0;
 
     if( !d->m_errorItems.empty() )
     {
         qCDebug(OUTPUTVIEW) << "searching next error";
         // Jump to the next error item
         std::set< int >::const_iterator next = d->m_errorItems.lower_bound( startrow );
         if( next == d->m_errorItems.end() )
             next = d->m_errorItems.begin();
 
         return index( *next, 0, QModelIndex() );
     }
 
     for( int row = 0; row < rowCount(); ++row )
     {
         int currow = (startrow + row) % rowCount();
         if( d->m_filteredItems.at( currow ).isActivatable )
         {
             return index( currow, 0, QModelIndex() );
         }
     }
     return QModelIndex();
 }
 
 QModelIndex OutputModel::previousHighlightIndex( const QModelIndex &currentIdx )
 {
     //We have to ensure that startrow is >= rowCount - 1 to get a positive value from the % operation.
     int startrow = rowCount() + (d->isValidIndex(currentIdx, rowCount()) ? currentIdx.row() : rowCount()) - 1;
 
     if(!d->m_errorItems.empty())
     {
         qCDebug(OUTPUTVIEW) << "searching previous error";
 
         // Jump to the previous error item
         std::set< int >::const_iterator previous = d->m_errorItems.lower_bound( currentIdx.row() );
 
         if( previous == d->m_errorItems.begin() )
             previous = d->m_errorItems.end();
 
         --previous;
 
         return index( *previous, 0, QModelIndex() );
     }
 
     for ( int row = 0; row < rowCount(); ++row )
     {
         int currow = (startrow - row) % rowCount();
         if( d->m_filteredItems.at( currow ).isActivatable )
         {
             return index( currow, 0, QModelIndex() );
         }
     }
     return QModelIndex();
 }
 
 QModelIndex OutputModel::lastHighlightIndex()
 {
     if( !d->m_errorItems.empty() ) {
         return index( *d->m_errorItems.rbegin(), 0, QModelIndex() );
     }
 
     for( int row = rowCount()-1; row >=0; --row ) {
         if( d->m_filteredItems.at( row ).isActivatable ) {
             return index( row, 0, QModelIndex() );
         }
     }
 
     return QModelIndex();
 }
 
 void OutputModel::setFilteringStrategy(const OutputFilterStrategy& currentStrategy)
 {
     // TODO: Turn into factory, decouple from OutputModel
     IFilterStrategy* filter = nullptr;
     switch( currentStrategy )
     {
         case NoFilter:
             filter = new NoFilterStrategy;
             break;
         case CompilerFilter:
             filter = new CompilerFilterStrategy( d->m_buildDir );
             break;
         case ScriptErrorFilter:
             filter = new ScriptErrorFilterStrategy;
             break;
         case NativeAppErrorFilter:
             filter = new NativeAppErrorFilterStrategy;
             break;
         case StaticAnalysisFilter:
             filter = new StaticAnalysisFilterStrategy;
             break;
         default:
             // assert(false);
             filter = new NoFilterStrategy;
             break;
     }
     Q_ASSERT(filter);
 
     QMetaObject::invokeMethod(d->worker, "changeFilterStrategy",
                               Q_ARG(KDevelop::IFilterStrategy*, filter));
 }
 
 void OutputModel::setFilteringStrategy(IFilterStrategy* filterStrategy)
 {
     QMetaObject::invokeMethod(d->worker, "changeFilterStrategy",
                               Q_ARG(KDevelop::IFilterStrategy*, filterStrategy));
 }
 
 void OutputModel::appendLines( const QStringList& lines )
 {
     if( lines.isEmpty() )
         return;
 
     QMetaObject::invokeMethod(d->worker, "addLines",
                               Q_ARG(QStringList, lines));
 }
 
-void OutputModel::appendLine( const QString& l )
+void OutputModel::appendLine( const QString& line )
 {
-    appendLines( QStringList() << l );
+    appendLines( QStringList() << line );
 }
 
 void OutputModel::ensureAllDone()
 {
     QMetaObject::invokeMethod(d->worker, "flushBuffers");
 }
 
+void OutputModel::clear()
+{
+    ensureAllDone();
+    beginResetModel();
+    d->m_filteredItems.clear();
+    endResetModel();
+}
+
 }
 
 #include "outputmodel.moc"
 #include "moc_outputmodel.cpp"
diff --git a/outputview/outputmodel.h b/outputview/outputmodel.h
index 9878b51ff..df2838746 100644
--- a/outputview/outputmodel.h
+++ b/outputview/outputmodel.h
@@ -1,96 +1,97 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                         *
  *   Copyright (C) 2012  Morten Danielsen Volden mvolden2@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 Library 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_OUTPUTMODEL_H
 #define KDEVPLATFORM_OUTPUTMODEL_H
 
 #include "outputviewexport.h"
 #include "ioutputviewmodel.h"
 #include "ifilterstrategy.h"
 
 #include <QtCore/QAbstractListModel>
 #include <QUrl>
 
 
 namespace KDevelop
 {
 
 struct FilteredItem;
 struct OutputModelPrivate;
 
 class KDEVPLATFORMOUTPUTVIEW_EXPORT OutputModel : public QAbstractListModel, public KDevelop::IOutputViewModel
 {
     Q_OBJECT
 public:
 
     enum CustomRoles {
         OutputItemTypeRole = Qt::UserRole + 1
     };
 
     enum OutputFilterStrategy
     {
         NoFilter,
         CompilerFilter,
         ScriptErrorFilter,
         NativeAppErrorFilter,
         StaticAnalysisFilter
     };
 
     explicit OutputModel( const QUrl& builddir , QObject* parent = nullptr );
     explicit OutputModel( QObject* parent = nullptr );
     ~OutputModel() override;
 
     /// IOutputViewModel interfaces
     void activate( const QModelIndex& index ) override;
     QModelIndex firstHighlightIndex() override;
     QModelIndex nextHighlightIndex( const QModelIndex &current ) override;
     QModelIndex previousHighlightIndex( const QModelIndex &current ) override;
     QModelIndex lastHighlightIndex() override;
 
     /// QAbstractItemModel interfaces
     QVariant data( const QModelIndex&, int = Qt::DisplayRole ) const override;
     int rowCount( const QModelIndex& = QModelIndex() ) const override;
     QVariant headerData( int, Qt::Orientation, int = Qt::DisplayRole ) const override;
 
     void setFilteringStrategy(const OutputFilterStrategy& currentStrategy);
     void setFilteringStrategy(IFilterStrategy* filterStrategy);
 
 public Q_SLOTS:
     void appendLine( const QString& );
     void appendLines( const QStringList& );
     void ensureAllDone();
+    void clear();
 
 signals:
     /// If the current filter strategy supports it, reports progress information
     void progress(const KDevelop::IFilterStrategy::Progress& progress);
     void allDone();
 
 private:
     OutputModelPrivate* const d;
     friend struct OutputModelPrivate;
 };
 
 }
 
 Q_DECLARE_METATYPE( KDevelop::OutputModel::OutputFilterStrategy )
 
 #endif
 
diff --git a/plugins/standardoutputview/outputwidget.cpp b/plugins/standardoutputview/outputwidget.cpp
index c36d64aaa..b6c2fb43d 100644
--- a/plugins/standardoutputview/outputwidget.cpp
+++ b/plugins/standardoutputview/outputwidget.cpp
@@ -1,660 +1,678 @@
 /* This file is part of KDevelop
  *
  * Copyright 2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2007 Dukju Ahn <dukjuahn@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 "outputwidget.h"
 
 #include "standardoutputview.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QIcon>
 #include <QLineEdit>
 #include <QRegExp>
 #include <QSortFilterProxyModel>
 #include <QStackedWidget>
 #include <QTabWidget>
 #include <QToolButton>
 #include <QTreeView>
 #include <QVBoxLayout>
 #include <QWidgetAction>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <KToggleAction>
 
 #include <outputview/ioutputviewmodel.h>
 #include <util/focusedtreeview.h>
 
+#include "outputmodel.h"
 #include "toolviewdata.h"
 #include "debug.h"
 
 Q_LOGGING_CATEGORY(PLUGIN_STANDARDOUTPUTVIEW, "kdevplatform.plugins.standardoutputview")
 Q_DECLARE_METATYPE(QTreeView*)
 
 OutputWidget::OutputWidget(QWidget* parent, const ToolViewData* tvdata)
     : QWidget( parent )
     , tabwidget(nullptr)
     , stackwidget(nullptr)
     , data(tvdata)
     , m_closeButton(nullptr)
     , m_closeOthersAction(nullptr)
     , nextAction(nullptr)
     , previousAction(nullptr)
     , activateOnSelect(nullptr)
     , focusOnSelect(nullptr)
     , filterInput(nullptr)
     , filterAction(nullptr)
 {
     setWindowTitle(i18n("Output View"));
     setWindowIcon(tvdata->icon);
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->setMargin(0);
     if( data->type & KDevelop::IOutputView::MultipleView )
     {
         tabwidget = new QTabWidget(this);
         layout->addWidget( tabwidget );
         m_closeButton = new QToolButton( this );
         connect( m_closeButton, &QToolButton::clicked, this, &OutputWidget::closeActiveView );
         m_closeButton->setIcon( QIcon::fromTheme( QStringLiteral( "tab-close") ) );
         m_closeButton->setToolTip( i18n( "Close the currently active output view") );
         m_closeButton->setAutoRaise(true);
 
         m_closeOthersAction = new QAction( this );
         connect(m_closeOthersAction, &QAction::triggered, this, &OutputWidget::closeOtherViews);
         m_closeOthersAction->setIcon(QIcon::fromTheme(QStringLiteral("tab-close-other")));
         m_closeOthersAction->setToolTip( i18n( "Close all other output views" ) );
         m_closeOthersAction->setText( m_closeOthersAction->toolTip() );
         addAction(m_closeOthersAction);
 
         tabwidget->setCornerWidget(m_closeButton, Qt::TopRightCorner);
     } else if ( data->type == KDevelop::IOutputView::HistoryView )
     {
         stackwidget = new QStackedWidget( this );
         layout->addWidget( stackwidget );
 
         previousAction = new QAction( QIcon::fromTheme( QStringLiteral( "arrow-left" ) ), i18n("Previous Output"), this );
         connect(previousAction, &QAction::triggered, this, &OutputWidget::previousOutput);
         addAction(previousAction);
         nextAction = new QAction( QIcon::fromTheme( QStringLiteral( "arrow-right" ) ), i18n("Next Output"), this );
         connect(nextAction, &QAction::triggered, this, &OutputWidget::nextOutput);
         addAction(nextAction);
     }
 
     addAction(dynamic_cast<QAction*>(data->plugin->actionCollection()->action(QStringLiteral("prev_error"))));
     addAction(dynamic_cast<QAction*>(data->plugin->actionCollection()->action(QStringLiteral("next_error"))));
 
     activateOnSelect = new KToggleAction( QIcon(), i18n("Select activated Item"), this );
     activateOnSelect->setChecked( true );
     focusOnSelect = new KToggleAction( QIcon(), i18n("Focus when selecting Item"), this );
     focusOnSelect->setChecked( false );
     if( data->option & KDevelop::IOutputView::ShowItemsButton )
     {
         addAction(activateOnSelect);
         addAction(focusOnSelect);
     }
 
     QAction *separator = new QAction(this);
     separator->setSeparator(true);
     addAction(separator);
 
     QAction* action;
 
     action = new QAction(QIcon::fromTheme(QStringLiteral("go-first")), i18n("First Item"), this);
     connect(action, &QAction::triggered, this, &OutputWidget::selectFirstItem);
     addAction(action);
 
     action = new QAction(QIcon::fromTheme(QStringLiteral("go-previous")), i18n("Previous Item"), this);
     connect(action, &QAction::triggered, this, &OutputWidget::selectPreviousItem);
     addAction(action);
 
     action = new QAction(QIcon::fromTheme(QStringLiteral("go-next")), i18n("Next Item"), this);
     connect(action, &QAction::triggered, this, &OutputWidget::selectNextItem);
     addAction(action);
 
     action = new QAction(QIcon::fromTheme(QStringLiteral("go-last")), i18n("Last Item"), this);
     connect(action, &QAction::triggered, this, &OutputWidget::selectLastItem);
     addAction(action);
 
     QAction* selectAllAction = KStandardAction::selectAll(this, SLOT(selectAll()), this);
     selectAllAction->setShortcut(QKeySequence()); //FIXME: why does CTRL-A conflict with Katepart (while CTRL-Cbelow doesn't) ?
     selectAllAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     addAction(selectAllAction);
 
     QAction* copyAction = KStandardAction::copy(this, SLOT(copySelection()), this);
     copyAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     addAction(copyAction);
 
     if( data->option & KDevelop::IOutputView::AddFilterAction )
     {
         QAction *separator = new QAction(this);
         separator->setSeparator(true);
         addAction(separator);
 
         filterInput = new QLineEdit();
         filterInput->setMaximumWidth(150);
         filterInput->setMinimumWidth(100);
         filterInput->setPlaceholderText(i18n("Search..."));
         filterInput->setClearButtonEnabled(true);
         filterInput->setToolTip(i18n("Enter a wild card string to filter the output view"));
         filterAction = new QWidgetAction(this);
         filterAction->setDefaultWidget(filterInput);
         addAction(filterAction);
 
         connect(filterInput, &QLineEdit::textEdited,
                 this, &OutputWidget::outputFilter );
         if( data->type & KDevelop::IOutputView::MultipleView )
         {
             connect(tabwidget, &QTabWidget::currentChanged,
                     this, &OutputWidget::updateFilter);
         } else if ( data->type == KDevelop::IOutputView::HistoryView )
         {
             connect(stackwidget, &QStackedWidget::currentChanged,
                     this, &OutputWidget::updateFilter);
         }
     }
 
+    QAction *clearAction = new QAction("Clear");
+    connect(clearAction, &QAction::triggered, [=]{
+        auto view = qobject_cast<QAbstractItemView*>(currentWidget());
+        if( !view || !view->isVisible())
+            return;
+
+        KDevelop::OutputModel *outputModel = nullptr;
+        if ( QAbstractProxyModel* proxy = qobject_cast<QAbstractProxyModel*>(view->model())) {
+            outputModel = dynamic_cast<KDevelop::OutputModel*>(proxy->sourceModel());
+        } else {
+            outputModel = dynamic_cast<KDevelop::OutputModel*>(view->model());
+        }
+        outputModel->clear();
+    });
+
+    addAction(clearAction);
+
     addActions(data->actionList);
 
     connect( data, &ToolViewData::outputAdded,
              this, &OutputWidget::addOutput );
 
     connect( this, &OutputWidget::outputRemoved,
              data->plugin, &StandardOutputView::outputRemoved );
 
     foreach( int id, data->outputdata.keys() )
     {
         changeModel( id );
         changeDelegate( id );
     }
     enableActions();
 }
 
 void OutputWidget::addOutput( int id )
 {
     QTreeView* listview = createListView(id);
     setCurrentWidget( listview );
     connect( data->outputdata.value(id), &OutputData::modelChanged, this, &OutputWidget::changeModel);
     connect( data->outputdata.value(id), &OutputData::delegateChanged, this, &OutputWidget::changeDelegate);
 
     enableActions();
 }
 
 void OutputWidget::setCurrentWidget( QTreeView* view )
 {
     if( data->type & KDevelop::IOutputView::MultipleView )
     {
         tabwidget->setCurrentWidget( view );
     } else if( data->type & KDevelop::IOutputView::HistoryView )
     {
         stackwidget->setCurrentWidget( view );
     }
 }
 
 void OutputWidget::changeDelegate( int id )
 {
     if( data->outputdata.contains( id ) && views.contains( id ) ) {
         views.value(id)->setItemDelegate(data->outputdata.value(id)->delegate);
     } else {
         addOutput(id);
     }
 }
 
 void OutputWidget::changeModel( int id )
 {
     if( data->outputdata.contains( id ) && views.contains( id ) )
     {
         OutputData* od = data->outputdata.value(id);
         views.value( id )->setModel(od->model);
     }
     else
     {
         addOutput( id );
     }
 }
 
 void OutputWidget::removeOutput( int id )
 {
     if( data->outputdata.contains( id ) && views.contains( id ) )
     {
         QTreeView* view = views.value(id);
         if( data->type & KDevelop::IOutputView::MultipleView || data->type & KDevelop::IOutputView::HistoryView )
         {
             if( data->type & KDevelop::IOutputView::MultipleView )
             {
                 int idx = tabwidget->indexOf( view );
                 if( idx != -1 )
                 {
                     tabwidget->removeTab( idx );
                     if( proxyModels.contains( idx ) )
                     {
                         delete proxyModels.take( idx );
                         filters.remove( idx );
                     }
                 }
             } else
             {
                 int idx = stackwidget->indexOf( view );
                 if( idx != -1 && proxyModels.contains( idx ) )
                 {
                     delete proxyModels.take( idx );
                     filters.remove( idx );
                 }
                 stackwidget->removeWidget( view );
             }
             delete view;
         } else
         {
             views.value( id )->setModel( nullptr );
             views.value( id )->setItemDelegate( nullptr );
             if( proxyModels.contains( 0 ) ) {
                 delete proxyModels.take( 0 );
                 filters.remove( 0 );
             }
         }
         views.remove( id );
         emit outputRemoved( data->toolViewId, id );
     }
     enableActions();
 }
 
 void OutputWidget::closeActiveView()
 {
     QWidget* widget = tabwidget->currentWidget();
     if( !widget )
         return;
     foreach( int id, views.keys() )
     {
         if( views.value(id) == widget )
         {
             OutputData* od = data->outputdata.value(id);
             if( od->behaviour & KDevelop::IOutputView::AllowUserClose )
             {
                 data->plugin->removeOutput( id );
             }
         }
     }
     enableActions();
 }
 
 void OutputWidget::closeOtherViews()
 {
     QWidget* widget = tabwidget->currentWidget();
     if (!widget)
         return;
 
     foreach (int id, views.keys()) {
         if (views.value(id) == widget) {
             continue; // leave the active view open
         }
 
         OutputData* od = data->outputdata.value(id);
         if (od->behaviour & KDevelop::IOutputView::AllowUserClose) {
             data->plugin->removeOutput( id );
         }
     }
     enableActions();
 }
 
 QWidget* OutputWidget::currentWidget() const
 {
     QWidget* widget;
     if( data->type & KDevelop::IOutputView::MultipleView )
     {
         widget = tabwidget->currentWidget();
     } else if( data->type & KDevelop::IOutputView::HistoryView )
     {
         widget = stackwidget->currentWidget();
     } else
     {
         widget = views.begin().value();
     }
     return widget;
 }
 
 KDevelop::IOutputViewModel *OutputWidget::outputViewModel() const
 {
     auto view = qobject_cast<QAbstractItemView*>(currentWidget());
     if( !view || !view->isVisible())
         return nullptr;
 
     QAbstractItemModel *absmodel = view->model();
     KDevelop::IOutputViewModel *iface = dynamic_cast<KDevelop::IOutputViewModel*>(absmodel);
     if ( ! iface )
     {
         // try if it's a proxy model?
         if ( QAbstractProxyModel* proxy = qobject_cast<QAbstractProxyModel*>(absmodel) )
         {
             iface = dynamic_cast<KDevelop::IOutputViewModel*>(proxy->sourceModel());
         }
     }
     return iface;
 }
 
 void OutputWidget::eventuallyDoFocus()
 {
     QWidget* widget = currentWidget();
     if( focusOnSelect->isChecked() && !widget->hasFocus() ) {
         widget->setFocus( Qt::OtherFocusReason );
     }
 }
 
 QAbstractItemView *OutputWidget::outputView() const
 {
     return qobject_cast<QAbstractItemView*>(currentWidget());
 }
 
 void OutputWidget::activateIndex(const QModelIndex &index, QAbstractItemView *view, KDevelop::IOutputViewModel *iface)
 {
     if( ! index.isValid() )
         return;
     int tabIndex = currentOutputIndex();
     QModelIndex sourceIndex = index;
     QModelIndex viewIndex = index;
     if( QAbstractProxyModel* proxy = proxyModels.value(tabIndex) ) {
         if ( index.model() == proxy ) {
             // index is from the proxy, map it to the source
             sourceIndex = proxy->mapToSource(index);
         } else if (proxy == view->model()) {
             // index is from the source, map it to the proxy
             viewIndex = proxy->mapFromSource(index);
         }
     }
 
     view->setCurrentIndex( viewIndex );
     view->scrollTo( viewIndex );
 
     if( activateOnSelect->isChecked() ) {
         iface->activate( sourceIndex );
     }
 }
 
 void OutputWidget::selectFirstItem()
 {
     selectItem(First);
 }
 
 void OutputWidget::selectNextItem()
 {
     selectItem(Next);
 }
 
 void OutputWidget::selectPreviousItem()
 {
     selectItem(Previous);
 }
 
 void OutputWidget::selectLastItem()
 {
     selectItem(Last);
 }
 
 void OutputWidget::selectItem(SelectionMode selectionMode)
 {
     auto view = outputView();
     auto iface = outputViewModel();
     if ( ! view || ! iface )
         return;
     eventuallyDoFocus();
 
     auto index = view->currentIndex();
 
     if (QAbstractProxyModel* proxy = proxyModels.value(currentOutputIndex())) {
         if ( index.model() == proxy ) {
             // index is from the proxy, map it to the source
             index = proxy->mapToSource(index);
         }
     }
 
     QModelIndex newIndex;
     switch (selectionMode) {
         case First:
             newIndex = iface->firstHighlightIndex();
             break;
         case Next:
             newIndex = iface->nextHighlightIndex( index );
             break;
         case Previous:
             newIndex = iface->previousHighlightIndex( index );
             break;
         case Last:
             newIndex = iface->lastHighlightIndex();
             break;
     }
 
     qCDebug(PLUGIN_STANDARDOUTPUTVIEW) << "old:" << index << "- new:" << newIndex;
     activateIndex(newIndex, view, iface);
 }
 
 void OutputWidget::activate(const QModelIndex& index)
 {
     auto iface = outputViewModel();
     auto view = outputView();
     if( ! view || ! iface )
         return;
     activateIndex(index, view, iface);
 }
 
 QTreeView* OutputWidget::createListView(int id)
 {
     auto createHelper = [&]() -> QTreeView* {
         KDevelop::FocusedTreeView* listview = new KDevelop::FocusedTreeView(this);
         listview->setEditTriggers( QAbstractItemView::NoEditTriggers );
         listview->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn); //Always enable the scrollbar, so it doesn't flash around
         listview->setHeaderHidden(true);
         listview->setUniformRowHeights(true);
         listview->setRootIsDecorated(false);
         listview->setSelectionMode( QAbstractItemView::ContiguousSelection );
 
         if (data->outputdata.value(id)->behaviour & KDevelop::IOutputView::AutoScroll) {
             listview->setAutoScrollAtEnd(true);
         }
 
         connect(listview, &QTreeView::activated, this, &OutputWidget::activate);
         connect(listview, &QTreeView::clicked, this, &OutputWidget::activate);
 
         return listview;
     };
 
     QTreeView* listview = nullptr;
     if( !views.contains(id) )
     {
         bool newView = true;
 
         if( data->type & KDevelop::IOutputView::MultipleView || data->type & KDevelop::IOutputView::HistoryView )
         {
             qCDebug(PLUGIN_STANDARDOUTPUTVIEW) << "creating listview";
             listview = createHelper();
 
             if( data->type & KDevelop::IOutputView::MultipleView )
             {
                 tabwidget->addTab( listview, data->outputdata.value(id)->title );
             } else
             {
                 stackwidget->addWidget( listview );
                 stackwidget->setCurrentWidget( listview );
             }
         } else
         {
             if( views.isEmpty() )
             {
                 listview = createHelper();
 
                 layout()->addWidget( listview );
             } else
             {
                 listview = views.begin().value();
                 newView = false;
             }
         }
         views[id] = listview;
 
         changeModel( id );
         changeDelegate( id );
 
         if (newView)
             listview->scrollToBottom();
     } else
     {
         listview = views.value(id);
     }
     enableActions();
     return listview;
 }
 
 void OutputWidget::raiseOutput(int id)
 {
     if( views.contains(id) )
     {
         if( data->type & KDevelop::IOutputView::MultipleView )
         {
             int idx = tabwidget->indexOf( views.value(id) );
             if( idx >= 0 )
             {
                 tabwidget->setCurrentIndex( idx );
             }
         } else if( data->type & KDevelop::IOutputView::HistoryView )
         {
             int idx = stackwidget->indexOf( views.value(id) );
             if( idx >= 0 )
             {
                 stackwidget->setCurrentIndex( idx );
             }
         }
     }
     enableActions();
 }
 
 void OutputWidget::nextOutput()
 {
     if( stackwidget && stackwidget->currentIndex() < stackwidget->count()-1 )
     {
         stackwidget->setCurrentIndex( stackwidget->currentIndex()+1 );
     }
     enableActions();
 }
 
 void OutputWidget::previousOutput()
 {
     if( stackwidget && stackwidget->currentIndex() > 0 )
     {
         stackwidget->setCurrentIndex( stackwidget->currentIndex()-1 );
     }
     enableActions();
 }
 
 void OutputWidget::enableActions()
 {
     if( data->type == KDevelop::IOutputView::HistoryView )
     {
         Q_ASSERT(stackwidget);
         Q_ASSERT(nextAction);
         Q_ASSERT(previousAction);
         previousAction->setEnabled( ( stackwidget->currentIndex() > 0 ) );
         nextAction->setEnabled( ( stackwidget->currentIndex() < stackwidget->count() - 1 ) );
     }
 }
 
 void OutputWidget::scrollToIndex( const QModelIndex& idx )
 {
     QWidget* w = currentWidget();
     if( !w )
         return;
     QAbstractItemView *view = dynamic_cast<QAbstractItemView*>(w);
     view->scrollTo( idx );
 }
 
 void OutputWidget::copySelection()
 {
     QWidget* widget = currentWidget();
     if( !widget )
         return;
     QAbstractItemView *view = dynamic_cast<QAbstractItemView*>(widget);
     if( !view )
         return;
 
     QClipboard *cb = QApplication::clipboard();
     QModelIndexList indexes = view->selectionModel()->selectedRows();
     QString content;
     Q_FOREACH( const QModelIndex& index, indexes) {
       content += index.data().toString() + '\n';
     }
     cb->setText(content);
 }
 
 void OutputWidget::selectAll()
 {
     if (QAbstractItemView *view = qobject_cast<QAbstractItemView*>(currentWidget()))
         view->selectAll();
 }
 
 int OutputWidget::currentOutputIndex()
 {
     int index = 0;
     if( data->type & KDevelop::IOutputView::MultipleView )
     {
         index = tabwidget->currentIndex();
     } else if( data->type & KDevelop::IOutputView::HistoryView )
     {
         index = stackwidget->currentIndex();
     }
     return index;
 }
 
 void OutputWidget::outputFilter(const QString& filter)
 {
     QAbstractItemView *view = qobject_cast<QAbstractItemView*>(currentWidget());
     if( !view )
         return;
     int index = currentOutputIndex();
     auto proxyModel = qobject_cast<QSortFilterProxyModel*>(view->model());
     if( !proxyModel )
     {
         proxyModel = new QSortFilterProxyModel(view->model());
         proxyModel->setDynamicSortFilter(true);
         proxyModel->setSourceModel(view->model());
         proxyModels.insert(index, proxyModel);
         view->setModel(proxyModel);
     }
     QRegExp regExp(filter, Qt::CaseInsensitive);
     proxyModel->setFilterRegExp(regExp);
     filters[index] = filter;
 }
 
 void OutputWidget::updateFilter(int index)
 {
     if(filters.contains(index))
     {
         filterInput->setText(filters[index]);
     } else
     {
         filterInput->clear();
     }
 }
 
 void OutputWidget::setTitle(int outputId, const QString& title)
 {
     if( data->type & KDevelop::IOutputView::MultipleView ) {
         tabwidget->setTabText(outputId - 1, title);
     }
 }