diff --git a/forwardingmodel.cpp b/forwardingmodel.cpp
index 88a606d67..522be7d24 100644
--- a/forwardingmodel.cpp
+++ b/forwardingmodel.cpp
@@ -1,206 +1,208 @@
 /***************************************************************************
  *   Copyright (C) 2015 by Eike Hein <hein@kde.org>                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) 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 "forwardingmodel.h"
 
 ForwardingModel::ForwardingModel(QObject *parent) : AbstractModel(parent)
 {
 }
 
 ForwardingModel::~ForwardingModel()
 {
 }
 
 QAbstractItemModel *ForwardingModel::sourceModel() const
 {
     return m_sourceModel;
 }
 
 void ForwardingModel::setSourceModel(QAbstractItemModel *sourceModel)
 {
     disconnectSignals();
 
     beginResetModel();
 
     m_sourceModel = sourceModel;
 
-    endResetModel();
-
     connectSignals();
 
+    endResetModel();
+
     emit countChanged();
 
     emit sourceModelChanged();
 }
 
 bool ForwardingModel::canFetchMore(const QModelIndex &parent) const
 {
     if (!m_sourceModel) {
         return false;
     }
 
     return m_sourceModel->canFetchMore(indexToSourceIndex(parent));
 }
 
 void ForwardingModel::fetchMore(const QModelIndex &parent)
 {
     if (m_sourceModel) {
         m_sourceModel->fetchMore(indexToSourceIndex(parent));
     }
 }
 
 QModelIndex ForwardingModel::index(int row, int column, const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
     if (!m_sourceModel) {
         return QModelIndex();
     }
 
     return createIndex(row, column);
 }
 
 QModelIndex ForwardingModel::parent(const QModelIndex &index) const
 {
     Q_UNUSED(index)
 
     return QModelIndex();
 }
 
 QVariant ForwardingModel::data(const QModelIndex &index, int role) const
 {
     if (!m_sourceModel) {
         return QVariant();
     }
 
     return m_sourceModel->data(indexToSourceIndex(index), role);
 }
 
 int ForwardingModel::rowCount(const QModelIndex &parent) const
 {
     if (!m_sourceModel) {
         return 0;
     }
 
     return m_sourceModel->rowCount(indexToSourceIndex(parent));
 }
 
 QModelIndex ForwardingModel::indexToSourceIndex(const QModelIndex& index) const
 {
     if (!m_sourceModel || !index.isValid()) {
         return QModelIndex();
     }
 
     return m_sourceModel->index(index.row(), index.column(),
         index.parent().isValid() ? indexToSourceIndex(index.parent()) : QModelIndex());
 }
 
 bool ForwardingModel::trigger(int row, const QString &actionId, const QVariant &argument)
 {
     if (!m_sourceModel) {
         return false;
     }
 
     AbstractModel *abstractModel = qobject_cast<AbstractModel *>(m_sourceModel);
 
     if (!abstractModel) {
         return false;
     }
 
     return abstractModel->trigger(row, actionId, argument);
 }
 
 AbstractModel* ForwardingModel::modelForRow(int row)
 {
     if (!m_sourceModel) {
         return 0;
     }
 
     AbstractModel *abstractModel = qobject_cast<AbstractModel *>(m_sourceModel);
 
     if (!abstractModel) {
         return 0;
     }
 
     return abstractModel->modelForRow(row);
 }
 
 void ForwardingModel::reset()
 {
     emit beginResetModel();
     emit endResetModel();
     emit countChanged();
 }
 
 void ForwardingModel::connectSignals()
 {
     if (!m_sourceModel) {
         return;
     }
 
     connect(m_sourceModel, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
             this, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
             this, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
             this, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
             this, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(layoutAboutToBeChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
             this, SIGNAL(layoutAboutToBeChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
             this, SIGNAL(rowsInserted(QModelIndex,int,int)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
             this, SIGNAL(countChanged()), Qt::UniqueConnection);
+    connect(m_sourceModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
+            this, SLOT(foo(QModelIndex,int,int)), Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
             this, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SIGNAL(countChanged()), Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(modelAboutToBeReset()),
             this, SIGNAL(modelAboutToBeReset()),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(modelReset()),
             this, SIGNAL(modelReset()),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(modelReset()),
             this, SIGNAL(countChanged()),
             Qt::UniqueConnection);
     connect(m_sourceModel, SIGNAL(layoutChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
             this, SIGNAL(layoutChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
             Qt::UniqueConnection);
 }
 
 void ForwardingModel::disconnectSignals()
 {
     if (!m_sourceModel) {
         return;
     }
 
     disconnect(m_sourceModel, 0, this, 0);
 }
diff --git a/funnelmodel.cpp b/funnelmodel.cpp
index 88b2cc51e..aaa436e55 100644
--- a/funnelmodel.cpp
+++ b/funnelmodel.cpp
@@ -1,92 +1,94 @@
 /***************************************************************************
  *   Copyright (C) 2014 by Eike Hein <hein@kde.org>                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) 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 "funnelmodel.h"
 
 FunnelModel::FunnelModel(QObject *parent) : ForwardingModel(parent)
 {
 }
 
 FunnelModel::~FunnelModel()
 {
 }
 
 void FunnelModel::setSourceModel(QAbstractItemModel *model)
 {
     if (model && m_sourceModel == model) {
         return;
     }
 
     if (!model) {
         reset();
 
         return;
     }
 
     connect(model, SIGNAL(destroyed(QObject*)), this, SLOT(reset()));
 
     if (!m_sourceModel) {
         emit beginResetModel();
 
         m_sourceModel = model;
 
+        connectSignals();
+
         emit endResetModel();
 
         emit countChanged();
 
         emit sourceModelChanged();
 
         return;
     }
 
     int oldCount = m_sourceModel->rowCount();
     int newCount = model->rowCount();
 
     disconnectSignals();
 
     m_sourceModel = model;
 
     connectSignals();
 
     if (newCount > oldCount) {
         beginInsertRows(QModelIndex(), oldCount, newCount - 1);
 
         endInsertRows();
     } else if (newCount < oldCount) {
         if (newCount == 0) {
             beginResetModel();
 
             endResetModel();
         } else {
             beginRemoveRows(QModelIndex(), newCount, oldCount - 1);
 
             endRemoveRows();
         }
     }
 
     if (newCount > 0) {
         emit dataChanged(index(0, 0), index(qMin(oldCount, newCount) - 1, 0));
     }
 
     if (oldCount != newCount) {
         emit countChanged();
     }
 
     emit sourceModelChanged();
 }
diff --git a/recentappsmodel.cpp b/recentappsmodel.cpp
index 592039736..161563c4f 100644
--- a/recentappsmodel.cpp
+++ b/recentappsmodel.cpp
@@ -1,172 +1,178 @@
 /***************************************************************************
  *   Copyright (C) 2014-2015 by Eike Hein <hein@kde.org>                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) 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 "recentappsmodel.h"
 #include "actionlist.h"
 #include "appsmodel.h"
 
 #include <config-X11.h>
 
 #include <QIcon>
 #if HAVE_X11
 #include <QX11Info>
 #endif
 
 #include <KActivities/ResourceInstance>
 #include <KLocalizedString>
 #include <KRun>
 #include <KService>
 #include <KStartupInfo>
 
 #include <KActivitiesExperimentalStats/Cleaning>
 #include <KActivitiesExperimentalStats/ResultModel>
 #include <KActivitiesExperimentalStats/Terms>
 
 namespace KAStats = KActivities::Experimental::Stats;
 
 using namespace KAStats;
 using namespace KAStats::Terms;
 
 RecentAppsModel::RecentAppsModel(QObject *parent) : ForwardingModel(parent)
 {
     refresh();
 }
 
 RecentAppsModel::~RecentAppsModel()
 {
 }
 
 QVariant RecentAppsModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     const QString storageId = sourceModel()->data(index, ResultModel::ResourceRole).toString().section(':', 1);
     KService::Ptr service = KService::serviceByStorageId(storageId);
 
     if (!service || !service->isApplication()) {
         return QVariant();
     }
 
     if (role == Qt::DisplayRole) {
             return AppsModel::nameFromService(service,
                 (AppsModel::NameFormat)qobject_cast<AppsModel *>(QObject::parent())->appNameFormat());
     } else if (role == Qt::DecorationRole) {
         return QIcon::fromTheme(service->icon(), QIcon::fromTheme("unknown"));
     } else if (role == Kicker::HasActionListRole) {
         return true;
     } else if (role == Kicker::ActionListRole) {
         QVariantList actionList;
 
         actionList << Kicker::recentDocumentActions(service);
 
         if (actionList.count()) {
             actionList << Kicker::createSeparatorActionItem();
         }
 
         const QVariantMap &forgetAction = Kicker::createActionItem(i18n("Forget Application"), "forget");
         actionList << forgetAction;
 
         const QVariantMap &forgetAllAction = Kicker::createActionItem(i18n("Forget All Applications"), "forgetAll");
         actionList << forgetAllAction;
 
         return actionList;
     }
 
     return QVariant();
 }
 
 bool RecentAppsModel::trigger(int row, const QString &actionId, const QVariant &argument)
 {
     Q_UNUSED(argument)
 
     if (row < 0 || row >= rowCount()) {
         return false;
     }
 
     if (actionId.isEmpty()) {
         const QString storageId = sourceModel()->data(sourceModel()->index(row, 0),
             ResultModel::ResourceRole).toString().section(':', 1);
         KService::Ptr service = KService::serviceByStorageId(storageId);
 
         if (!service) {
             return false;
         }
 
         quint32 timeStamp = 0;
 
 #if HAVE_X11
         if (QX11Info::isPlatformX11()) {
             timeStamp = QX11Info::appUserTime();
         }
 #endif
 
         new KRun(QUrl::fromLocalFile(service->entryPath()), 0, true,
             KStartupInfo::createNewStartupIdForTimestamp(timeStamp));
 
         KActivities::ResourceInstance::notifyAccessed(QUrl("applications:" + storageId),
             "org.kde.plasma.kicker");
 
         return true;
     } else if (actionId == "forget") {
         if (sourceModel()) {
             ResultModel *resultModel = static_cast<ResultModel *>(sourceModel());
             resultModel->forgetResource(row);
         }
 
         return false;
     } else if (actionId == "forgetAll") {
         if (sourceModel()) {
             ResultModel *resultModel = static_cast<ResultModel *>(sourceModel());
             resultModel->forgetAllResources();
         }
 
         return true;
     } else {
         const QString storageId = sourceModel()->data(sourceModel()->index(row, 0),
             ResultModel::ResourceRole).toString().section(':', 1);
         KService::Ptr service = KService::serviceByStorageId(storageId);
 
         if (service) {
             return Kicker::handleRecentDocumentAction(service, actionId, argument);
         }
     }
 
     return false;
 }
 
 void RecentAppsModel::refresh()
 {
     QObject *oldModel = sourceModel();
 
     auto query = UsedResources
                     | RecentlyUsedFirst
                     | Agent::any()
                     | Type::any()
                     | Activity::current()
                     | Url::startsWith("applications:");
 
     ResultModel *model = new ResultModel(query);
     model->setItemCountLimit(15);
 
+    QModelIndex index;
+
+    if (model->canFetchMore(index)) {
+        model->fetchMore(index);
+    }
+
     setSourceModel(model);
 
     delete oldModel;
 }
diff --git a/recentcontactsmodel.cpp b/recentcontactsmodel.cpp
index ad688d7ac..183300219 100644
--- a/recentcontactsmodel.cpp
+++ b/recentcontactsmodel.cpp
@@ -1,222 +1,227 @@
 /***************************************************************************
  *   Copyright (C) 2012 by Aurélien Gâteau <agateau@kde.org>               *
  *   Copyright (C) 2014-2015 by Eike Hein <hein@kde.org>                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) 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 "recentcontactsmodel.h"
 #include "actionlist.h"
 
 #include <QAction>
 
 #include <KLocalizedString>
 
 #include <KActivitiesExperimentalStats/ResultModel>
 #include <KActivitiesExperimentalStats/Terms>
 
 #include <kpeople/widgets/actions.h> //FIXME TODO: Pretty include in KPeople broken.
 #include <kpeople/widgets/persondetailsdialog.h>
 #include <KPeople/PersonData>
 
 namespace KAStats = KActivities::Experimental::Stats;
 
 using namespace KAStats;
 using namespace KAStats::Terms;
 
 RecentContactsModel::RecentContactsModel(QObject *parent) : ForwardingModel(parent)
 {
     refresh();
 }
 
 RecentContactsModel::~RecentContactsModel()
 {
 }
 
 QVariant RecentContactsModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     QString id = sourceModel()->data(index, ResultModel::ResourceRole).toString();
 
     KPeople::PersonData *data = 0;
 
     if (m_idToData.contains(id)) {
         data = m_idToData[id];
     }
 
     if (!data) {
         const_cast<RecentContactsModel *>(this)->insertPersonData(id, index.row());
         return QVariant();
     }
 
     if (role == Qt::DisplayRole) {
         return data->name();
     } else if (role == Qt::DecorationRole) {
         return data->presenceIconName();
     } else if (role == Kicker::HasActionListRole) {
         return true;
     } else if (role == Kicker::ActionListRole) {
         QVariantList actionList ;
 
         const QVariantMap &forgetAction = Kicker::createActionItem(i18n("Forget Contact"), "forget");
         actionList << forgetAction;
 
         const QVariantMap &forgetAllAction = Kicker::createActionItem(i18n("Forget All Contacts"), "forgetAll");
         actionList << forgetAllAction;
 
         actionList << Kicker::createSeparatorActionItem();
 
         actionList << Kicker::createActionItem(i18n("Show Contact Information..."), "showContactInfo");
 
         return actionList;
     }
 
     return QVariant();
 }
 
 bool RecentContactsModel::trigger(int row, const QString &actionId, const QVariant &argument)
 {
     Q_UNUSED(argument)
 
     if (row < 0 || row >= rowCount()) {
         return false;
     }
 
     if (actionId.isEmpty()) {
         QString id = sourceModel()->data(sourceModel()->index(row, 0), ResultModel::ResourceRole).toString();
 
         const QList<QAction *> actionList = KPeople::actionsForPerson(id, this);
 
         if (!actionList.isEmpty()) {
             QAction *chat = 0;
 
             foreach (QAction *action, actionList) {
                 const QVariant &actionType = action->property("actionType");
 
                 if (!actionType.isNull() && actionType.toInt() == KPeople::ActionType::TextChatAction) {
                     chat = action;
                 }
             }
 
             if (chat) {
                 chat->trigger();
 
                 return true;
             }
         }
 
         return false;
     } else if (actionId == "showContactInfo") {
         QString id = sourceModel()->data(sourceModel()->index(row, 0), ResultModel::ResourceRole).toString();
 
         KPeople::PersonDetailsDialog *view = new KPeople::PersonDetailsDialog(0);
         KPeople::PersonData *data = new KPeople::PersonData(id, view);
         view->setPerson(data);
         view->setAttribute(Qt::WA_DeleteOnClose);
         view->show();
     } else if (actionId == "forget") {
         if (sourceModel()) {
             ResultModel *resultModel = static_cast<ResultModel *>(sourceModel());
             resultModel->forgetResource(row);
         }
 
         return false;
     } else if (actionId == "forgetAll") {
         if (sourceModel()) {
             ResultModel *resultModel = static_cast<ResultModel *>(sourceModel());
             resultModel->forgetAllResources();
         }
 
         return true;
     }
 
     return false;
 }
 
 void RecentContactsModel::refresh()
 {
     QObject *oldModel = sourceModel();
 
     auto query = UsedResources
                     | RecentlyUsedFirst
                     | Agent("KTp")
                     | Type::any()
                     | Activity::current()
                     | Url::startsWith("ktp");
 
     ResultModel *model = new ResultModel(query);
     model->setItemCountLimit(15);
-    model->fetchMore(QModelIndex());
+
+    QModelIndex index;
+
+    if (model->canFetchMore(index)) {
+        model->fetchMore(index);
+    }
 
     // FIXME TODO: Don't wipe entire cache on transactions.
     connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
             this, SLOT(buildCache()), Qt::UniqueConnection);
     connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SLOT(buildCache()), Qt::UniqueConnection);
     connect(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
             this, SLOT(buildCache()), Qt::UniqueConnection);
     connect(model, SIGNAL(modelReset()),
             this, SLOT(buildCache()), Qt::UniqueConnection);
 
     setSourceModel(model);
 
     buildCache();
 
     delete oldModel;
 }
 
 void RecentContactsModel::buildCache()
 {
     qDeleteAll(m_idToData.values());
     m_idToData.clear();
     m_dataToRow.clear();
 
     QString id;
 
     for(int i = 0; i < sourceModel()->rowCount(); ++i) {
         id = sourceModel()->data(sourceModel()->index(i, 0), ResultModel::ResourceRole).toString();
 
         if (!m_idToData.contains(id)) {
             insertPersonData(id, i);
         }
     }
 }
 
 void RecentContactsModel::insertPersonData(const QString& id, int row)
 {
     KPeople::PersonData *data = new KPeople::PersonData(id);
 
     m_idToData[id] = data;
     m_dataToRow[data] = row;
 
     connect(data, SIGNAL(dataChanged()), this, SLOT(personDataChanged()));
 }
 
 void RecentContactsModel::personDataChanged()
 {
     KPeople::PersonData *data = static_cast<KPeople::PersonData *>(sender());
 
     if (m_dataToRow.contains(data)) {
         int row = m_dataToRow[data];
 
         QModelIndex idx = sourceModel()->index(row, 0);
 
         emit dataChanged(idx, idx);
     }
 }
diff --git a/recentdocsmodel.cpp b/recentdocsmodel.cpp
index 541d14fe1..d134dfc54 100644
--- a/recentdocsmodel.cpp
+++ b/recentdocsmodel.cpp
@@ -1,140 +1,146 @@
 /***************************************************************************
  *   Copyright (C) 2012 by Aurélien Gâteau <agateau@kde.org>               *
  *   Copyright (C) 2014-2015 by Eike Hein <hein@kde.org>                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) 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 "recentdocsmodel.h"
 #include "actionlist.h"
 
 #include <QIcon>
 
 #include <KFileItem>
 #include <KLocalizedString>
 #include <KRun>
 
 #include <KActivitiesExperimentalStats/Cleaning>
 #include <KActivitiesExperimentalStats/ResultModel>
 #include <KActivitiesExperimentalStats/Terms>
 
 namespace KAStats = KActivities::Experimental::Stats;
 
 using namespace KAStats;
 using namespace KAStats::Terms;
 
 RecentDocsModel::RecentDocsModel(QObject *parent) : ForwardingModel(parent)
 {
     refresh();
 }
 
 RecentDocsModel::~RecentDocsModel()
 {
 }
 
 QVariant RecentDocsModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     const QUrl url(sourceModel()->data(index, ResultModel::ResourceRole).toString());
     const KFileItem fileItem(url);
 
     if (!url.isValid() || !fileItem.isFile()) {
         return QVariant();
     }
 
     if (role == Qt::DisplayRole) {
         return url.fileName();
     } else if (role == Qt::DecorationRole) {
         return QIcon::fromTheme(fileItem.iconName(), QIcon::fromTheme("unknown"));
     } else if (role == Kicker::HasActionListRole) {
         return true;
     } else if (role == Kicker::ActionListRole) {
         QVariantList actionList = Kicker::createActionListForFileItem(fileItem);
 
         actionList << Kicker::createSeparatorActionItem();
 
         const QVariantMap &forgetAction = Kicker::createActionItem(i18n("Forget Document"), "forget");
         actionList << forgetAction;
 
         const QVariantMap &forgetAllAction = Kicker::createActionItem(i18n("Forget All Documents"), "forgetAll");
         actionList << forgetAllAction;
 
         return actionList;
     }
 
     return QVariant();
 }
 
 bool RecentDocsModel::trigger(int row, const QString &actionId, const QVariant &argument)
 {
     if (row < 0 || row >= rowCount()) {
         return false;
     }
 
     QUrl url(sourceModel()->data(sourceModel()->index(row, 0), ResultModel::ResourceRole).toString());
 
     if (actionId.isEmpty()) {
         new KRun(url, 0);
 
         return true;
     } else if (actionId == "forget") {
         if (sourceModel()) {
             ResultModel *resultModel = static_cast<ResultModel *>(sourceModel());
             resultModel->forgetResource(row);
         }
 
         return false;
     } else if (actionId == "forgetAll") {
         if (sourceModel()) {
             ResultModel *resultModel = static_cast<ResultModel *>(sourceModel());
             resultModel->forgetAllResources();
         }
 
         return true;
     }
 
     bool close = false;
 
     KFileItem item(url);
 
     if (Kicker::handleFileItemAction(item, actionId, argument, &close)) {
         return close;
     }
 
     return false;
 }
 
 void RecentDocsModel::refresh()
 {
     QObject *oldModel = sourceModel();
 
     auto query = UsedResources
                     | RecentlyUsedFirst
                     | Agent::any()
                     | Type::any()
                     | Activity::current()
                     | Url::file();
 
     ResultModel *model = new ResultModel(query);
     model->setItemCountLimit(15);
 
+    QModelIndex index;
+
+    if (model->canFetchMore(index)) {
+        model->fetchMore(index);
+    }
+
     setSourceModel(model);
 
     delete oldModel;
 }