diff --git a/appsmodel.cpp b/appsmodel.cpp
index 100ac5aa1..821ae88a2 100644
--- a/appsmodel.cpp
+++ b/appsmodel.cpp
@@ -1,510 +1,512 @@
 /***************************************************************************
  *   Copyright (C) 2012 Aurélien Gâteau <agateau@kde.org>                  *
  *   Copyright (C) 2013-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 "appsmodel.h"
 #include "actionlist.h"
 
 #include <QCollator>
 #include <QQmlPropertyMap>
 #include <QTimer>
 
 #include <KLocalizedString>
 #include <KSycoca>
 
 AppsModel::AppsModel(const QString &entryPath, bool flat, bool separators, QObject *parent)
 : AbstractModel(parent)
 , m_deleteEntriesOnDestruction(true)
 , m_separatorCount(0)
 , m_showSeparators(separators)
 , m_description(i18n("Applications"))
 , m_entryPath(entryPath)
 , m_staticEntryList(false)
 , m_changeTimer(0)
 , m_flat(flat)
 , m_sortNeeded(false)
 , m_appNameFormat(AppEntry::NameOnly)
 {
     if (!m_entryPath.isEmpty()) {
         refresh();
     }
 }
 
 AppsModel::AppsModel(const QList<AbstractEntry *> entryList, bool deleteEntriesOnDestruction, QObject *parent)
 : AbstractModel(parent)
 , m_deleteEntriesOnDestruction(deleteEntriesOnDestruction)
 , m_separatorCount(0)
 , m_showSeparators(false)
 , m_description(i18n("Applications"))
 , m_entryPath(QString())
 , m_staticEntryList(true)
 , m_changeTimer(0)
 , m_flat(true)
 , m_sortNeeded(false)
 , m_appNameFormat(AppEntry::NameOnly)
 {
     foreach(AbstractEntry *suggestedEntry, entryList) {
         bool found = false;
 
         foreach (const AbstractEntry *entry, m_entryList) {
             if (entry->type() == AbstractEntry::RunnableType
                 && static_cast<const AppEntry *>(entry)->service()->storageId()
                 == static_cast<const AppEntry *>(suggestedEntry)->service()->storageId()) {
                 found = true;
             }
         }
 
         if (!found) {
             m_entryList << suggestedEntry;
         }
     }
 
     sortEntries();
 }
 
 AppsModel::~AppsModel()
 {
     if (m_deleteEntriesOnDestruction) {
         qDeleteAll(m_entryList);
     }
 }
 
 QString AppsModel::description() const
 {
     return m_description;
 }
 
 void AppsModel::setDescription(const QString &text)
 {
     if (m_description != text) {
         m_description = text;
 
         emit descriptionChanged();
     }
 }
 
 QVariant AppsModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() >= m_entryList.count()) {
         return QVariant();
     }
 
     const AbstractEntry *entry = m_entryList.at(index.row());
 
     if (role == Qt::DisplayRole) {
         return entry->name();
     } else if (role == Qt::DecorationRole) {
         return entry->icon();
     } else if (role == Kicker::FavoriteIdRole && entry->type() == AbstractEntry::RunnableType) {
         return entry->id();
+    } else if (role == Kicker::UrlRole && entry->type() == AbstractEntry::RunnableType) {
+        return entry->url();
     } else if (role == Kicker::IsParentRole) {
         return (entry->type() == AbstractEntry::GroupType);
     } else if (role == Kicker::IsSeparatorRole) {
         return (entry->type() == AbstractEntry::SeparatorType);
     } else if (role == Kicker::HasChildrenRole) {
         return entry->hasChildren();
     } else if (role == Kicker::HasActionListRole) {
         const AppsModel *appsModel = qobject_cast<const AppsModel *>(entry->childModel());
 
         return entry->hasActions() || (appsModel && !appsModel->hiddenEntries().isEmpty());
     } else if (role == Kicker::ActionListRole) {
         QVariantList actionList = entry->actions();
 
         if (!m_hiddenEntries.isEmpty()) {
             actionList << Kicker::createSeparatorActionItem();
             actionList << Kicker::createActionItem(i18n("Unhide Applications in this Submenu"), "unhideSiblingApplications");
         }
 
         const AppsModel *appsModel = qobject_cast<const AppsModel *>(entry->childModel());
 
         if (appsModel && !appsModel->hiddenEntries().isEmpty()) {
             actionList << Kicker::createActionItem(i18n("Unhide Applications in '%1'", entry->name()), "unhideChildApplications");
         }
 
         return actionList;
     }
 
     return QVariant();
 }
 
 QModelIndex AppsModel::index(int row, int column, const QModelIndex &parent) const
 {
     return hasIndex(row, column, parent) ? createIndex(row, column, m_entryList.at(row)) : QModelIndex();
 }
 
 
 int AppsModel::rowCount(const QModelIndex &parent) const
 {
     return parent.isValid() ? 0 : m_entryList.count();
 }
 
 bool AppsModel::trigger(int row, const QString &actionId, const QVariant &argument)
 {
     if (row < 0 || row >= m_entryList.count()) {
         return false;
     }
 
     AbstractEntry *entry = m_entryList.at(row);
 
     if (actionId == "hideApplication" && entry->type() == AbstractEntry::RunnableType) {
         QObject *appletInterface = rootModel()->property("appletInterface").value<QObject *>();
         QQmlPropertyMap *appletConfig = qobject_cast<QQmlPropertyMap *>(appletInterface->property("configuration").value<QObject *>());
 
         if (appletConfig && appletConfig->contains("hiddenApplications")) {
             QStringList hiddenApps = appletConfig->value("hiddenApplications").toStringList();
 
             KService::Ptr service = static_cast<const AppEntry *>(entry)->service();
 
             if (!hiddenApps.contains(service->menuId())) {
                 hiddenApps << service->menuId();
 
                 appletConfig->insert("hiddenApplications", hiddenApps);
                 QMetaObject::invokeMethod(appletConfig, "valueChanged", Qt::DirectConnection,
                     Q_ARG(QString, "hiddenApplications"),
                     Q_ARG(QVariant, hiddenApps));
 
                 refresh();
 
                 emit hiddenEntriesChanged();
             }
         }
 
         return false;
     } else if (actionId == "unhideSiblingApplications") {
         QObject *appletInterface = rootModel()->property("appletInterface").value<QObject *>();
         QQmlPropertyMap *appletConfig = qobject_cast<QQmlPropertyMap *>(appletInterface->property("configuration").value<QObject *>());
 
         if (appletConfig && appletConfig->contains("hiddenApplications")) {
             QStringList hiddenApps = appletConfig->value("hiddenApplications").toStringList();
 
             foreach(const QString& app, m_hiddenEntries) {
                 hiddenApps.removeOne(app);
             }
 
             appletConfig->insert("hiddenApplications", hiddenApps);
             QMetaObject::invokeMethod(appletConfig, "valueChanged", Qt::DirectConnection,
                 Q_ARG(QString, "hiddenApplications"),
                 Q_ARG(QVariant, hiddenApps));
 
             m_hiddenEntries.clear();
 
             refresh();
 
             emit hiddenEntriesChanged();
         }
 
         return false;
     } else if (actionId == "unhideChildApplications") {
         QObject *appletInterface = rootModel()->property("appletInterface").value<QObject *>();
         QQmlPropertyMap *appletConfig = qobject_cast<QQmlPropertyMap *>(appletInterface->property("configuration").value<QObject *>());
 
         if (entry->type() == AbstractEntry::GroupType
             && appletConfig && appletConfig->contains("hiddenApplications")) {
 
             const AppsModel *appsModel = qobject_cast<const AppsModel *>(entry->childModel());
 
             if (!appsModel) {
                 return false;
             }
 
             QStringList hiddenApps = appletConfig->value("hiddenApplications").toStringList();
 
             foreach(const QString& app, appsModel->hiddenEntries()) {
                 hiddenApps.removeOne(app);
             }
 
             appletConfig->insert("hiddenApplications", hiddenApps);
             QMetaObject::invokeMethod(appletConfig, "valueChanged", Qt::DirectConnection,
                 Q_ARG(QString, "hiddenApplications"),
                 Q_ARG(QVariant, hiddenApps));
 
             refresh();
 
             emit hiddenEntriesChanged();
         }
 
         return false;
     }
 
     return entry->run(actionId, argument);
 }
 
 AbstractModel *AppsModel::modelForRow(int row)
 {
     if (row < 0 || row >= m_entryList.count()) {
         return 0;
     }
 
     return m_entryList.at(row)->childModel();
 }
 
 int AppsModel::separatorCount() const
 {
     return m_separatorCount;
 }
 
 bool AppsModel::flat() const
 {
     return m_flat;
 }
 
 void AppsModel::setFlat(bool flat)
 {
     if (m_flat != flat) {
         m_flat = flat;
 
         refresh();
 
         emit flatChanged();
     }
 }
 
 bool AppsModel::showSeparators() const
 {
     return m_showSeparators;
 }
 
 void AppsModel::setShowSeparators(bool showSeparators) {
     if (m_showSeparators != showSeparators) {
         m_showSeparators = showSeparators;
 
         refresh();
 
         emit showSeparatorsChanged();
     }
 }
 
 int AppsModel::appNameFormat() const
 {
     return m_appNameFormat;
 }
 
 void AppsModel::setAppNameFormat(int format)
 {
     if (m_appNameFormat != (AppEntry::NameFormat)format) {
         m_appNameFormat = (AppEntry::NameFormat)format;
 
         refresh();
 
         emit appNameFormatChanged();
     }
 }
 
 QStringList AppsModel::hiddenEntries() const
 {
     return m_hiddenEntries;
 }
 
 void AppsModel::refresh()
 {
     if (m_staticEntryList) {
         return;
     }
 
     beginResetModel();
 
     refreshInternal();
 
     endResetModel();
 
     emit countChanged();
     emit separatorCountChanged();
 }
 
 void AppsModel::refreshInternal()
 {
     if (m_staticEntryList) {
         return;
     }
 
     if (m_entryList.count()) {
         qDeleteAll(m_entryList);
         m_entryList.clear();
         emit cleared();
     }
 
     m_hiddenEntries.clear();
     m_separatorCount = 0;
     m_sortNeeded = false;
 
     if (m_entryPath.isEmpty()) {
         KServiceGroup::Ptr group = KServiceGroup::root();
 
         bool sortByGenericName = (appNameFormat() == AppEntry::GenericNameOnly || appNameFormat() == AppEntry::GenericNameAndName);
 
         KServiceGroup::List list = group->entries(true /* sorted */, true /* excludeNoDisplay */,
             true /* allowSeparators */, sortByGenericName /* sortByGenericName */);
 
         for (KServiceGroup::List::ConstIterator it = list.constBegin(); it != list.constEnd(); it++) {
             const KSycocaEntry::Ptr p = (*it);
 
             if (p->isType(KST_KServiceGroup)) {
                 KServiceGroup::Ptr subGroup(static_cast<KServiceGroup*>(p.data()));
 
                 if (!subGroup->noDisplay() && subGroup->childCount() > 0) {
                     AppGroupEntry *groupEntry = new AppGroupEntry(this, subGroup, m_flat, m_showSeparators, m_appNameFormat);
                     m_entryList << groupEntry;
                 }
             }
         }
 
         m_changeTimer = new QTimer(this);
         m_changeTimer->setSingleShot(true);
         m_changeTimer->setInterval(100);
         connect(m_changeTimer, SIGNAL(timeout()), this, SLOT(refresh()));
 
         connect(KSycoca::self(), SIGNAL(databaseChanged(QStringList)), SLOT(checkSycocaChanges(QStringList)));
     } else {
         KServiceGroup::Ptr group = KServiceGroup::group(m_entryPath);
         processServiceGroup(group);
 
         if (m_entryList.count()) {
             while (m_entryList.last()->type() == AbstractEntry::SeparatorType) {
                 m_entryList.removeLast();
                 --m_separatorCount;
             }
         }
 
         if (m_sortNeeded) {
             sortEntries();
         }
     }
 }
 
 void AppsModel::processServiceGroup(KServiceGroup::Ptr group)
 {
     if (!group || !group->isValid()) {
         return;
     }
 
     bool hasSubGroups = false;
 
     foreach(KServiceGroup::Ptr subGroup, group->groupEntries(KServiceGroup::ExcludeNoDisplay)) {
         if (subGroup->childCount() > 0) {
             hasSubGroups = true;
 
             break;
         }
     }
 
     bool sortByGenericName = (appNameFormat() == AppEntry::GenericNameOnly || appNameFormat() == AppEntry::GenericNameAndName);
 
     KServiceGroup::List list = group->entries(true /* sorted */,
         true /* excludeNoDisplay */,
         (!m_flat || (m_flat && !hasSubGroups)) /* allowSeparators */,
         sortByGenericName /* sortByGenericName */);
 
     QStringList hiddenApps;
 
     QObject *appletInterface = rootModel()->property("appletInterface").value<QObject *>();
     QQmlPropertyMap *appletConfig = qobject_cast<QQmlPropertyMap *>(appletInterface->property("configuration").value<QObject *>());
 
     if (appletConfig && appletConfig->contains("hiddenApplications")) {
         hiddenApps = appletConfig->value("hiddenApplications").toStringList();
     }
 
     for (KServiceGroup::List::ConstIterator it = list.constBegin();
         it != list.constEnd(); it++) {
         const KSycocaEntry::Ptr p = (*it);
 
         if (p->isType(KST_KService)) {
             const KService::Ptr service(static_cast<KService*>(p.data()));
 
             if (service->noDisplay()) {
                 continue;
             }
 
             if (hiddenApps.contains(service->menuId())) {
                 m_hiddenEntries << service->menuId();
 
                 continue;
             }
 
             bool found = false;
 
             foreach (const AbstractEntry *entry, m_entryList) {
                 if (entry->type() == AbstractEntry::RunnableType
                     && static_cast<const AppEntry *>(entry)->service()->storageId() == service->storageId()) {
                     found = true;
                 }
             }
 
             if (!found) {
                 m_entryList << new AppEntry(this, service, m_appNameFormat);
             }
         } else if (p->isType(KST_KServiceSeparator) && m_showSeparators) {
             if (!m_entryList.count()) {
                 continue;
             }
 
             if (m_entryList.last()->type() == AbstractEntry::SeparatorType) {
                 continue;
             }
 
             m_entryList << new SeparatorEntry(this);
             ++m_separatorCount;
         } else if (p->isType(KST_KServiceGroup)) {
             const KServiceGroup::Ptr subGroup(static_cast<KServiceGroup*>(p.data()));
 
             if (subGroup->childCount() == 0) {
                 continue;
             }
 
             if (m_flat) {
                 m_sortNeeded = true;
                 const KServiceGroup::Ptr serviceGroup(static_cast<KServiceGroup*>(p.data()));
                 processServiceGroup(serviceGroup);
             } else {
                 AppGroupEntry *groupEntry = new AppGroupEntry(this, subGroup, m_flat, m_showSeparators, m_appNameFormat);
                 m_entryList << groupEntry;
             }
         }
     }
 }
 
 void AppsModel::sortEntries()
 {
     QCollator c;
 
     std::sort(m_entryList.begin(), m_entryList.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;
             }
         });
 }
 
 void AppsModel::checkSycocaChanges(const QStringList &changes)
 {
     if (changes.contains("services") || changes.contains("apps") || changes.contains("xdgdata-apps")) {
         m_changeTimer->start();
     }
 }
 
 void AppsModel::entryChanged(AbstractEntry *entry)
 {
     int i = m_entryList.indexOf(entry);
 
     if (i != -1) {
         QModelIndex idx = index(i, 0);
         emit dataChanged(idx, idx);
     }
 }
diff --git a/favoritesmodel.cpp b/favoritesmodel.cpp
index a5625354e..4931a1600 100644
--- a/favoritesmodel.cpp
+++ b/favoritesmodel.cpp
@@ -1,329 +1,331 @@
 /***************************************************************************
  *   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 "favoritesmodel.h"
 #include "appentry.h"
 #include "contactentry.h"
 #include "fileentry.h"
 #include "systementry.h"
 #include "actionlist.h"
 
 #include <KLocalizedString>
 
 FavoritesModel::FavoritesModel(QObject *parent) : AbstractModel(parent)
 , m_enabled(true)
 , m_maxFavorites(-1)
 , m_dropPlaceholderIndex(-1)
 {
 }
 
 FavoritesModel::~FavoritesModel()
 {
     qDeleteAll(m_entryList);
 }
 
 QString FavoritesModel::description() const
 {
     return i18n("Favorites");
 }
 
 QVariant FavoritesModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid() || index.row() >= rowCount()) {
         return QVariant();
     }
 
     if (index.row() == m_dropPlaceholderIndex) {
         if (role == Kicker::IsDropPlaceholderRole) {
             return true;
         } else {
             return QVariant();
         }
     }
 
     int mappedIndex = index.row();
 
     if (m_dropPlaceholderIndex != -1 && mappedIndex > m_dropPlaceholderIndex) {
         --mappedIndex;
     }
 
     const AbstractEntry *entry = m_entryList.at(mappedIndex);
 
     if (role == Qt::DisplayRole) {
         return entry->name();
     } else if (role == Qt::DecorationRole) {
         return entry->icon();
     } else if (role == Kicker::FavoriteIdRole) {
         return entry->id();
+    } else if (role == Kicker::UrlRole) {
+        return entry->url();
     } else if (role == Kicker::HasActionListRole) {
         return entry->hasActions();
     } else if (role == Kicker::ActionListRole) {
         return entry->actions();
     }
 
     return QVariant();
 }
 
 int FavoritesModel::rowCount(const QModelIndex& parent) const
 {
     return parent.isValid() ? 0 : m_entryList.count() + (m_dropPlaceholderIndex != -1 ? 1 : 0);
 }
 
 bool FavoritesModel::trigger(int row, const QString &actionId, const QVariant &argument)
 {
     if (row < 0 || row >= m_entryList.count()) {
         return false;
     }
 
     return m_entryList.at(row)->run(actionId, argument);
 }
 
 bool FavoritesModel::enabled() const
 {
     return m_enabled;
 }
 
 void FavoritesModel::setEnabled(bool enable)
 {
     if (m_enabled != enable) {
         m_enabled = enable;
 
         emit enabledChanged();
     }
 }
 
 QStringList FavoritesModel::favorites() const
 {
     return m_favorites;
 }
 
 void FavoritesModel::setFavorites(const QStringList& favorites)
 {
     QStringList _favorites(favorites);
     _favorites.removeDuplicates();
 
     if (_favorites != m_favorites) {
         m_favorites = _favorites;
         refresh();
     }
 }
 
 int FavoritesModel::maxFavorites() const
 {
     return m_maxFavorites;
 }
 
 void FavoritesModel::setMaxFavorites(int max)
 {
     if (m_maxFavorites != max)
     {
         m_maxFavorites = max;
 
         if (m_maxFavorites != -1 && m_favorites.count() > m_maxFavorites) {
             refresh();
         }
 
         emit maxFavoritesChanged();
     }
 }
 
 bool FavoritesModel::isFavorite(const QString &id) const
 {
     return m_favorites.contains(id);
 }
 
 void FavoritesModel::addFavorite(const QString &id, int index)
 {
     if (!m_enabled || id.isEmpty()) {
         return;
     }
 
     if (m_maxFavorites != -1 && m_favorites.count() == m_maxFavorites) {
         return;
     }
 
     AbstractEntry *entry = favoriteFromId(id);
 
     if (!entry || !entry->isValid()) {
         delete entry;
         return;
     }
 
     setDropPlaceholderIndex(-1);
 
     int insertIndex = (index != -1) ? index : m_entryList.count();
 
     beginInsertRows(QModelIndex(), insertIndex, insertIndex);
 
     m_entryList.insert(insertIndex, entry);
     m_favorites.insert(insertIndex, entry->id());
 
     endInsertRows();
 
     emit countChanged();
     emit favoritesChanged();
 }
 
 void FavoritesModel::removeFavorite(const QString &id)
 {
     if (!m_enabled || id.isEmpty()) {
         return;
     }
 
     int index = m_favorites.indexOf(id);
 
     if (index != -1) {
         setDropPlaceholderIndex(-1);
 
         beginRemoveRows(QModelIndex(), index, index);
 
         delete m_entryList[index];
         m_entryList.removeAt(index);
         m_favorites.removeAt(index);
 
         endRemoveRows();
 
         emit countChanged();
         emit favoritesChanged();
     }
 }
 
 void FavoritesModel::moveRow(int from, int to)
 {
     if (from >= m_favorites.count() || to >= m_favorites.count()) {
         return;
     }
 
     if (from == to) {
         return;
     }
 
     setDropPlaceholderIndex(-1);
 
     int modelTo = to + (to > from ? 1 : 0);
 
     bool ok = beginMoveRows(QModelIndex(), from, from, QModelIndex(), modelTo);
 
     if (ok) {
         m_entryList.move(from, to);
         m_favorites.move(from, to);
 
         endMoveRows();
 
         emit favoritesChanged();
     }
 }
 
 int FavoritesModel::dropPlaceholderIndex() const
 {
     return m_dropPlaceholderIndex;
 }
 
 void FavoritesModel::setDropPlaceholderIndex(int index)
 {
     if (index == -1 && m_dropPlaceholderIndex != -1) {
         beginRemoveRows(QModelIndex(), m_dropPlaceholderIndex, m_dropPlaceholderIndex);
 
         m_dropPlaceholderIndex = index;
 
         endRemoveRows();
 
         emit countChanged();
     } else if (index != -1 && m_dropPlaceholderIndex == -1) {
         beginInsertRows(QModelIndex(), index, index);
 
         m_dropPlaceholderIndex = index;
 
         endInsertRows();
 
         emit countChanged();
     } else if (m_dropPlaceholderIndex != index) {
         int modelTo = index + (index > m_dropPlaceholderIndex ? 1 : 0);
 
         bool ok = beginMoveRows(QModelIndex(), m_dropPlaceholderIndex, m_dropPlaceholderIndex, QModelIndex(), modelTo);
 
         if (ok) {
             m_dropPlaceholderIndex = index;
 
             endMoveRows();
         }
     }
 }
 
 AbstractModel *FavoritesModel::favoritesModel()
 {
     return this;
 }
 
 void FavoritesModel::refresh()
 {
     beginResetModel();
 
     setDropPlaceholderIndex(-1);
 
     int oldCount = m_entryList.count();
 
     qDeleteAll(m_entryList);
     m_entryList.clear();
 
     QStringList newFavorites;
 
     foreach(const QString &id, m_favorites) {
         AbstractEntry *entry = favoriteFromId(id);
 
         if (entry && entry->isValid()) {
             m_entryList << entry;
             newFavorites << entry->id();
 
             if (m_maxFavorites != -1 && newFavorites.count() == m_maxFavorites) {
                 break;
             }
         } else if (entry) {
             delete entry;
         }
     }
 
     m_favorites = newFavorites;
 
     endResetModel();
 
     if (oldCount != m_entryList.count()) {
         emit countChanged();
     }
 
     emit favoritesChanged();
 }
 
 AbstractEntry *FavoritesModel::favoriteFromId(const QString &id)
 {
     const QUrl url(id);
     const QString &s = url.scheme();
 
     if ((s.isEmpty() && id.contains(QStringLiteral(".desktop"))) || s == QStringLiteral("preferred")) {
         return new AppEntry(this, id);
     } else if (s == QStringLiteral("ktp")) {
         return new ContactEntry(this, id);
     } else if (url.isValid() && !url.scheme().isEmpty()) {
         return new FileEntry(this, url);
     } else {
         return new SystemEntry(this, id);
     }
 
     return nullptr;
 }