diff --git a/rootmodel.cpp b/rootmodel.cpp
index 48b5ac374..a36fa2be0 100644
--- a/rootmodel.cpp
+++ b/rootmodel.cpp
@@ -1,423 +1,426 @@
 /***************************************************************************
  *   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 "rootmodel.h"
 #include "actionlist.h"
 #include "favoritesmodel.h"
 #include "recentcontactsmodel.h"
 #include "recentusagemodel.h"
 #include "systemmodel.h"
 
 #include <KLocalizedString>
 
 #include <QCollator>
 
 GroupEntry::GroupEntry(AppsModel *parentModel, const QString &name,
     const QString &iconName, AbstractModel *childModel)
 : AbstractGroupEntry(parentModel)
 , m_name(name)
 , m_iconName(iconName)
 , m_childModel(childModel)
 {
     QObject::connect(parentModel, &RootModel::cleared, childModel, &AbstractModel::deleteLater);
 
     QObject::connect(childModel, &AbstractModel::countChanged,
         [parentModel, this] { if (parentModel) { parentModel->entryChanged(this); } }
     );
 }
 
 QString GroupEntry::name() const
 {
     return m_name;
 }
 
 QIcon GroupEntry::icon() const
 {
     return QIcon::fromTheme(m_iconName, QIcon::fromTheme("unknown"));
 }
 
 bool GroupEntry::hasChildren() const
 {
     return m_childModel && m_childModel->count() > 0;
 }
 
 AbstractModel *GroupEntry::childModel() const
 {
     return m_childModel;
 }
 
 RootModel::RootModel(QObject *parent) : AppsModel(QString(), parent)
 , m_complete(false)
 , m_favorites(new FavoritesModel(this))
 , m_systemModel(nullptr)
 , m_autoPopulate(true)
 , m_showAllApps(false)
 , m_showRecentApps(true)
 , m_showRecentDocs(true)
 , m_showRecentContacts(false)
 , m_showPowerSession(true)
 , m_recentAppsModel(0)
 , m_recentDocsModel(0)
 , m_recentContactsModel(0)
 {
 }
 
 RootModel::~RootModel()
 {
 }
 
 QVariant RootModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid() || index.row() >= m_entryList.count()) {
         return QVariant();
     }
 
     if (role == Kicker::HasActionListRole || role == Kicker::ActionListRole) {
         const AbstractEntry *entry = m_entryList.at(index.row());
 
         if (entry->type() == AbstractEntry::GroupType) {
             const GroupEntry *group = static_cast<const GroupEntry *>(entry);
             AbstractModel *model = group->childModel();
 
             if (model == m_recentAppsModel
                 || model == m_recentDocsModel
                 || model == m_recentContactsModel) {
                 if (role ==  Kicker::HasActionListRole) {
                     return true;
                 } else if (role == Kicker::ActionListRole) {
                     QVariantList actionList;
                     actionList << model->actions();
                     actionList << Kicker::createSeparatorActionItem();
                     actionList << Kicker::createActionItem(i18n("Hide %1",
                         group->name()), "hideCategory");
                     return actionList;
                 }
             }
         }
     }
 
     return AppsModel::data(index, role);
 }
 
 bool RootModel::trigger(int row, const QString& actionId, const QVariant& argument)
 {
     const AbstractEntry *entry = m_entryList.at(row);
 
     if (entry->type() == AbstractEntry::GroupType) {
         if (actionId == "hideCategory") {
             AbstractModel *model = entry->childModel();
 
             if (model == m_recentAppsModel) {
                 setShowRecentApps(false);
 
                 return true;
             } else if (model == m_recentDocsModel) {
                 setShowRecentDocs(false);
 
                 return true;
             } else if (model == m_recentContactsModel) {
                 setShowRecentContacts(false);
 
                 return true;
             }
         } else if (entry->childModel()->hasActions()) {
             return entry->childModel()->trigger(-1, actionId, QVariant());
         }
     }
 
     return AppsModel::trigger(row, actionId, argument);
 }
 
 bool RootModel::autoPopulate() const
 {
     return m_autoPopulate;
 }
 
 void RootModel::setAutoPopulate(bool populate)
 {
     if (m_autoPopulate != populate) {
         m_autoPopulate = populate;
 
         emit autoPopulateChanged();
     }
 }
 
 bool RootModel::showAllApps() const
 {
     return m_showAllApps;
 }
 
 void RootModel::setShowAllApps(bool show)
 {
     if (m_showAllApps != show) {
         m_showAllApps = show;
 
         refresh();
 
         emit showAllAppsChanged();
     }
 }
 
 bool RootModel::showRecentApps() const
 {
     return m_showRecentApps;
 }
 
 void RootModel::setShowRecentApps(bool show)
 {
     if (show != m_showRecentApps) {
         m_showRecentApps = show;
 
         refresh();
 
         emit showRecentAppsChanged();
     }
 }
 
 bool RootModel::showRecentDocs() const
 {
     return m_showRecentDocs;
 }
 
 void RootModel::setShowRecentDocs(bool show)
 {
     if (show != m_showRecentDocs) {
         m_showRecentDocs = show;
 
         refresh();
 
         emit showRecentDocsChanged();
     }
 }
 
 bool RootModel::showRecentContacts() const
 {
     return m_showRecentContacts;
 }
 
 void RootModel::setShowRecentContacts(bool show)
 {
     if (show != m_showRecentContacts) {
         m_showRecentContacts = show;
 
         refresh();
 
         emit showRecentContactsChanged();
     }
 }
 
 bool RootModel::showPowerSession() const
 {
     return m_showPowerSession;
 }
 
 void RootModel::setShowPowerSession(bool show)
 {
     if (show != m_showPowerSession) {
         m_showPowerSession = show;
 
         refresh();
 
         emit showPowerSessionChanged();
     }
 }
 
 AbstractModel* RootModel::favoritesModel()
 {
     return m_favorites;
 }
 
 AbstractModel* RootModel::systemFavoritesModel()
 {
     if (m_systemModel) {
         return m_systemModel->favoritesModel();
     }
 
     return nullptr;
 }
 
 void RootModel::classBegin()
 {
 }
 
 void RootModel::componentComplete()
 {
     m_complete = true;
 
     if (m_autoPopulate) {
         refresh();
     }
 }
 
 void RootModel::refresh()
 {
     if (!m_complete) {
         return;
     }
 
     beginResetModel();
 
     AppsModel::refreshInternal();
 
     AppsModel *allModel = nullptr;
     m_recentAppsModel = nullptr;
     m_recentDocsModel = nullptr;
     m_recentContactsModel = nullptr;
 
     if (m_showAllApps) {
         QList<AbstractEntry *> groups;
 
         if (m_paginate) {
+            m_favorites = new FavoritesModel(this);
+            emit favoritesModelChanged();
+
             QHash<QString, AppEntry *> appsHash;
             QList<AppEntry *> apps;
 
             foreach (const AbstractEntry *groupEntry, m_entryList) {
                 AbstractModel *model = groupEntry->childModel();
 
                 for (int i = 0; i < model->count(); ++i) {
                     GroupEntry *subGroupEntry = static_cast<GroupEntry*>(model->index(i, 0).internalPointer());
                     AbstractModel *subModel = subGroupEntry->childModel();
 
                     for (int j = 0; j < subModel->count(); ++j) {
                         AppEntry *appEntry = static_cast<AppEntry*>(subModel->index(j, 0).internalPointer());
 
                         if (appEntry->name().isEmpty()) {
                             continue;
                         }
 
                         appsHash.insert(appEntry->service()->menuId(), appEntry);
                     }
                 }
             }
 
             apps = appsHash.values();
 
             QCollator c;
 
             std::sort(apps.begin(), apps.end(),
                 [&c](AbstractEntry* a, AbstractEntry* b) {
                     if (a->type() != b->type()) {
                         return a->type() > b->type();
                     } else {
                         return c.compare(a->name(), b->name()) < 0;
                     }
                 });
 
 
             int at = 0;
             QList<AbstractEntry *> page;
             page.reserve(m_pageSize);
 
             foreach(AppEntry *app, apps) {
                 page.append(app);
 
                 if (at == (m_pageSize - 1)) {
                     at = 0;
                     AppsModel *model = new AppsModel(page, false, this);
                     groups.append(new GroupEntry(this, QString(), QString(), model));
                     page.clear();
                 } else {
                     ++at;
                 }
             }
 
             if (!page.isEmpty()) {
                 AppsModel *model = new AppsModel(page, false, this);
                 groups.append(new GroupEntry(this, QString(), QString(), model));
             }
 
             groups.prepend(new GroupEntry(this, QString(), QString(), m_favorites));
         } else {
             QHash<QString, QList<AbstractEntry *>> m_categoryHash;
 
             foreach (const AbstractEntry *groupEntry, m_entryList) {
                 AbstractModel *model = groupEntry->childModel();
 
                 for (int i = 0; i < model->count(); ++i) {
                     AbstractEntry *appEntry = static_cast<AbstractEntry *>(model->index(i, 0).internalPointer());
 
                     if (appEntry->name().isEmpty()) {
                         continue;
                     }
 
                     const QChar &first = appEntry->name().at(0).toUpper();
                     m_categoryHash[first.isDigit() ? QStringLiteral("0-9") : first].append(appEntry);
                 }
             }
 
             QHashIterator<QString, QList<AbstractEntry *>> i(m_categoryHash);
 
             while (i.hasNext()) {
                 i.next();
                 AppsModel *model = new AppsModel(i.value(), false, this);
                 model->setDescription(i.key());
                 groups.append(new GroupEntry(this, i.key(), QString(), model));
             }
         }
 
         allModel = new AppsModel(groups, true, this);
         allModel->setDescription(QStringLiteral("KICKER_ALL_MODEL")); // Intentionally no i18n.
     }
 
     int separatorPosition = 0;
 
     if (allModel) {
         m_entryList.prepend(new GroupEntry(this, i18n("All Applications"), QString(), allModel));
         ++separatorPosition;
     }
 
     if (m_showRecentContacts) {
         m_recentContactsModel = new RecentContactsModel(this);
         m_entryList.prepend(new GroupEntry(this, i18n("Recent Contacts"), QString(), m_recentContactsModel));
         ++separatorPosition;
     }
 
     if (m_showRecentDocs) {
         m_recentDocsModel = new RecentUsageModel(this, RecentUsageModel::OnlyDocs);
         m_entryList.prepend(new GroupEntry(this, i18n("Recent Documents"), QString(), m_recentDocsModel));
         ++separatorPosition;
     }
 
     if (m_showRecentApps) {
         m_recentAppsModel = new RecentUsageModel(this, RecentUsageModel::OnlyApps);
         m_entryList.prepend(new GroupEntry(this, i18n("Recent Applications"), QString(), m_recentAppsModel));
         ++separatorPosition;
     }
 
     if (m_showSeparators && separatorPosition > 0) {
         m_entryList.insert(separatorPosition, new SeparatorEntry(this));
         ++m_separatorCount;
     }
 
     m_systemModel = new SystemModel(this);
 
     if (m_showPowerSession) {
         m_entryList << new GroupEntry(this, i18n("Power / Session"), QString(), m_systemModel);
     }
 
     endResetModel();
 
     m_favorites->refresh();
 
     emit systemFavoritesModelChanged();
     emit countChanged();
     emit separatorCountChanged();
 
     emit refreshed();
 }