diff --git a/discover/qml/ReviewsPage.qml b/discover/qml/ReviewsPage.qml
index a6a69233..847e2696 100644
--- a/discover/qml/ReviewsPage.qml
+++ b/discover/qml/ReviewsPage.qml
@@ -1,78 +1,79 @@
 /***************************************************************************
  *   Copyright © 2012 Aleix Pol Gonzalez <aleixpol@blue-systems.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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 import QtQuick 2.1
 import QtQuick.Controls 1.1
 import org.kde.discover 2.0
 import org.kde.discover.app 1.0
 import org.kde.kirigami 2.0 as Kirigami
 
 Kirigami.OverlaySheet {
     id: page
     property alias model: reviewsView.model
     readonly property QtObject reviewsBackend: resource.backend.reviewsBackend
     readonly property var resource: model.resource
 
     readonly property var rd: ReviewDialog {
         id: reviewDialog
         application: page.resource
         parent: overlay
         onAccepted: page.reviewsBackend.submitReview(resource, summary, review, rating)
     }
 
     function openReviewDialog() {
         reviewDialog.sheetOpen = true
         page.sheetOpen = false
     }
 
     ListView {
         id: reviewsView
 
         clip: true
         spacing: Kirigami.Units.smallSpacing
         cacheBuffer: Math.max(0, contentHeight)
 
         header: Item {
             width: parent.width
             height: reviewButton.height + 2 * Kirigami.Units.largeSpacing
             Button {
                 id: reviewButton
 
                 anchors {
                     verticalCenter: parent.verticalCenter
                     left: parent.left
                     leftMargin: Kirigami.Units.largeSpacing
                 }
 
-                visible: page.reviewsBackend != null && page.resource.isInstalled
+                visible: page.reviewsBackend != null
+                enabled: page.resource.isInstalled
                 text: i18n("Review...")
                 onClicked: page.openReviewDialog()
             }
         }
 
         delegate: ReviewDelegate {
             anchors {
                 left: parent.left
                 right: parent.right
             }
             onMarkUseful: page.model.markUseful(index, useful)
         }
     }
 }
diff --git a/discover/qml/UpdatesPage.qml b/discover/qml/UpdatesPage.qml
index 0cab35e6..88a6e015 100644
--- a/discover/qml/UpdatesPage.qml
+++ b/discover/qml/UpdatesPage.qml
@@ -1,281 +1,282 @@
 import QtQuick.Controls 1.2
 import QtQuick.Controls 2.1 as QQC2
 import QtQuick.Layouts 1.1
 import QtQuick 2.4
 import org.kde.discover 2.0
 import org.kde.discover.app 1.0
 import org.kde.kquickcontrolsaddons 2.0
 import org.kde.kcoreaddons 1.0
 import "navigation.js" as Navigation
 import org.kde.kirigami 2.1 as Kirigami
 
 DiscoverPage
 {
     id: page
     title: i18n("Updates")
 
     property string footerLabel: ""
 
     ResourcesUpdatesModel {
         id: resourcesUpdatesModel
         onPassiveMessage: window.showPassiveNotification(message)
         onIsProgressingChanged: {
             if (!isProgressing) {
                 resourcesUpdatesModel.prepare()
             }
         }
 
         Component.onCompleted: {
             if (!isProgressing) {
                 resourcesUpdatesModel.prepare()
             }
         }
     }
 
     UpdateModel {
         id: updateModel
         backend: resourcesUpdatesModel
     }
 
     Kirigami.Action
     {
         id: updateAction
         text: page.unselected>0 ? i18n("Update Selected") : i18n("Update All")
         visible: updateModel.toUpdateCount
         iconName: "update-none"
         enabled: !resourcesUpdatesModel.isProgressing
         onTriggered: resourcesUpdatesModel.updateAll()
     }
 
     Kirigami.Action
     {
         id: cancelUpdateAction
         iconName: "dialog-cancel"
         text: i18n("Cancel")
         enabled: resourcesUpdatesModel.transaction && resourcesUpdatesModel.transaction.isCancellable
         onTriggered: resourcesUpdatesModel.transaction.cancel()
     }
 
     readonly property int unselected: (updateModel.totalUpdatesCount - updateModel.toUpdateCount)
     readonly property QtObject currentAction: resourcesUpdatesModel.isProgressing ? cancelUpdateAction : updateAction
     actions.main: applicationWindow().wideScreen ? null : currentAction
 
     header: QQC2.ToolBar {
         visible: (updateModel.totalUpdatesCount > 0 && resourcesUpdatesModel.isProgressing) || updateModel.hasUpdates
 
         RowLayout {
             anchors.fill: parent
             LabelBackground {
                 Layout.leftMargin: Kirigami.Units.gridUnit
                 text: updateModel.toUpdateCount + " (" + updateModel.updateSize+")"
             }
             QQC2.Label {
                 text: i18n("updates selected")
             }
             LabelBackground {
                 id: unselectedItem
                 text: page.unselected
                 visible: page.unselected>0
             }
             QQC2.Label {
                 text: i18n("updates not selected")
                 visible: unselectedItem.visible
             }
 
             Item {
                 Layout.fillWidth: true
             }
 
             Button {
                 Layout.minimumWidth: Kirigami.Units.gridUnit * 6
                 Layout.rightMargin: Kirigami.Units.gridUnit
                 text: page.currentAction.text
                 visible: !page.actions.main
                 onClicked: page.currentAction.trigger()
             }
         }
     }
 
     supportsRefreshing: true
     onRefreshingChanged: {
         showPassiveNotification("Fetching updates...")
         ResourcesModel.updateAction.triggered()
         refreshing = false
     }
     ListView
     {
         id: updatesView
         currentIndex: -1
 
         footer: ColumnLayout {
             anchors.right: parent.right
             anchors.left: parent.left
             Kirigami.Heading {
                 Layout.fillWidth: true
                 Layout.alignment: Qt.AlignHCenter
                 horizontalAlignment: Text.AlignHCenter
                 visible: page.footerLabel !== ""
                 text: page.footerLabel
             }
             Kirigami.Icon {
                 Layout.alignment: Qt.AlignHCenter
                 visible: page.footerLabel !== ""
                 source: "update-none"
                 opacity: 0.3
                 width: 200
                 height: 200
             }
             Item {
                 visible: page.footerLabel === ""
                 height: Kirigami.Units.gridUnit
                 width: 1
             }
         }
 
         model: updateModel
 
         section {
             property: "section"
             delegate: Kirigami.Heading {
                 x: Kirigami.Units.gridUnit
                 level: 2
                 text: section
             }
         }
 
         spacing: Kirigami.Units.smallSpacing
 
         delegate: Kirigami.AbstractListItem {
             backgroundColor: Kirigami.Theme.viewBackgroundColor
             x: Kirigami.Units.gridUnit
             width: ListView.view.width - Kirigami.Units.gridUnit * 2
             highlighted: ListView.isCurrentItem
             onEnabledChanged: if (!enabled) {
                 layout.extended = false;
             }
 
             Keys.onReturnPressed: {
                 itemChecked.clicked()
             }
             Keys.onPressed: if (event.key===Qt.Key_Alt) layout.extended = true
             Keys.onReleased: if (event.key===Qt.Key_Alt)  layout.extended = false
 
             ColumnLayout {
                 id: layout
                 property bool extended: false
                 onExtendedChanged: if (extended) {
                     updateModel.fetchChangelog(index)
                 }
                 RowLayout {
                     Layout.fillWidth: true
                     Layout.fillHeight: true
 
                     CheckBox {
                         id: itemChecked
                         anchors.verticalCenter: parent.verticalCenter
                         checked: model.checked == Qt.Checked
                         onClicked: model.checked = (model.checked==Qt.Checked ? Qt.Unchecked : Qt.Checked)
                     }
 
                     Kirigami.Icon {
                         Layout.fillHeight: true
                         Layout.preferredWidth: height
                         source: decoration
+                        smooth: true
                     }
 
                     QQC2.Label {
                         Layout.fillWidth: true
                         text: i18n("%1 (%2)", display, version)
                         elide: Text.ElideRight
                     }
 
                     LabelBackground {
                         Layout.minimumWidth: Kirigami.Units.gridUnit * 6
                         text: size
 
                         progress: resourceProgress/100
                     }
                 }
 
                 QQC2.Frame {
                     Layout.fillWidth: true
                     Layout.minimumHeight: view.contentHeight
                     visible: layout.extended && changelog.length>0
                     QQC2.Label {
                         id: view
                         anchors {
                             right: parent.right
                             left: parent.left
                         }
                         text: changelog
                         textFormat: Text.StyledText
                         wrapMode: Text.WordWrap
                         onLinkActivated: Qt.openUrlExternally(link)
                     }
                 }
 
                 Button {
                     Layout.alignment: Qt.AlignRight
                     text: i18n("More Information...")
                     visible: layout.extended
                     enabled: !resourcesUpdatesModel.isProgressing
                     onClicked: Navigation.openApplication(resource)
                 }
             }
 
             onClicked: {
                 layout.extended = !layout.extended
             }
         }
     }
 
     readonly property alias secSinceUpdate: resourcesUpdatesModel.secsToLastUpdate
     state:  ( updateModel.hasUpdates                     ? "has-updates"
             : ResourcesModel.isFetching                  ? "fetching"
             : resourcesUpdatesModel.isProgressing        ? "progressing"
             : secSinceUpdate < 0                         ? "unknown"
             : secSinceUpdate === 0                       ? "now-uptodate"
             : secSinceUpdate < 1000 * 60 * 60 * 24       ? "uptodate"
             : secSinceUpdate < 1000 * 60 * 60 * 24 * 7   ? "medium"
             :                                              "low"
             )
 
     states: [
         State {
             name: "fetching"
             PropertyChanges { target: page; title: i18nc("@info", "Fetching...") }
             PropertyChanges { target: page; footerLabel: i18nc("@info", "Looking for updates") }
         },
         State {
             name: "progressing"
             PropertyChanges { target: page; title: i18nc("@info", "Updating...") }
             PropertyChanges { target: page; footerLabel: resourcesUpdatesModel.progress<=0 ? i18nc("@info", "Fetching updates") : "" }
         },
         State {
             name: "has-updates"
             PropertyChanges { target: page; title: i18nc("@info", "Updates") }
         },
         State {
             name: "now-uptodate"
             PropertyChanges { target: page; title: i18nc("@info", "The system is up to date") }
             PropertyChanges { target: page; footerLabel: i18nc("@info", "No updates") }
         },
         State {
             name: "uptodate"
             PropertyChanges { target: page; title: i18nc("@info", "The system is up to date") }
             PropertyChanges { target: page; footerLabel: i18nc("@info", "No updates") }
         },
         State {
             name: "medium"
             PropertyChanges { target: page; title: i18nc("@info", "No updates are available") }
         },
         State {
             name: "low"
             PropertyChanges { target: page; title: i18nc("@info", "Should check for updates") }
         },
         State {
             name: "unknown"
             PropertyChanges { target: page; title: i18nc("@info", "It is unknown when the last check for updates was") }
         }
     ]
 }
diff --git a/libdiscover/resources/ResourcesProxyModel.cpp b/libdiscover/resources/ResourcesProxyModel.cpp
index 003fbbce..560f1b0d 100644
--- a/libdiscover/resources/ResourcesProxyModel.cpp
+++ b/libdiscover/resources/ResourcesProxyModel.cpp
@@ -1,541 +1,541 @@
 /***************************************************************************
  *   Copyright © 2010 Jonathan Thomas <echidnaman@kubuntu.org>             *
  *   Copyright © 2012 Aleix Pol Gonzalez <aleixpol@blue-systems.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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "ResourcesProxyModel.h"
 
 #include <QDebug>
 #include <QMetaProperty>
 #include <utils.h>
 
 #include "ResourcesModel.h"
 #include "AbstractResource.h"
 #include "AbstractResourcesBackend.h"
 #include <Category/CategoryModel.h>
 #include <ReviewsBackend/Rating.h>
 #include <Transaction/TransactionModel.h>
 
 ResourcesProxyModel::ResourcesProxyModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_sortRole(NameRole)
     , m_sortOrder(Qt::AscendingOrder)
     , m_sortByRelevancy(false)
     , m_roles({
         { NameRole, "name" },
         { IconRole, "icon" },
         { CommentRole, "comment" },
         { StateRole, "state" },
         { RatingRole, "rating" },
         { RatingPointsRole, "ratingPoints" },
         { RatingCountRole, "ratingCount" },
         { SortableRatingRole, "sortableRating" },
         { InstalledRole, "isInstalled" },
         { ApplicationRole, "application" },
         { OriginRole, "origin" },
         { DisplayOriginRole, "displayOrigin" },
         { CanUpgrade, "canUpgrade" },
         { PackageNameRole, "packageName" },
         { IsTechnicalRole, "isTechnical" },
         { CategoryRole, "category" },
         { CategoryDisplayRole, "categoryDisplay" },
         { SectionRole, "section" },
         { MimeTypes, "mimetypes" },
         { LongDescriptionRole, "longDescription" },
         { SizeRole, "size" }
         })
     , m_currentStream(nullptr)
 {
 //     new ModelTest(this, this);
 
     connect(ResourcesModel::global(), &ResourcesModel::backendsChanged, this, &ResourcesProxyModel::invalidateFilter);
     connect(ResourcesModel::global(), &ResourcesModel::backendDataChanged, this, &ResourcesProxyModel::refreshBackend);
     connect(ResourcesModel::global(), &ResourcesModel::resourceDataChanged, this, &ResourcesProxyModel::refreshResource);
     connect(ResourcesModel::global(), &ResourcesModel::resourceRemoved, this, &ResourcesProxyModel::removeResource);
 }
 
 void ResourcesProxyModel::componentComplete()
 {
     m_setup = true;
     invalidateFilter();
 }
 
 QHash<int, QByteArray> ResourcesProxyModel::roleNames() const
 {
     return m_roles;
 }
 
 void ResourcesProxyModel::setSortRole(Roles sortRole)
 {
     if (sortRole != m_sortRole) {
         Q_ASSERT(roleNames().contains(sortRole));
 
         m_sortRole = sortRole;
         Q_EMIT sortRoleChanged(sortRole);
         invalidateSorting();
     }
 }
 
 void ResourcesProxyModel::setSortOrder(Qt::SortOrder sortOrder)
 {
     if (sortOrder != m_sortOrder) {
         m_sortOrder = sortOrder;
         Q_EMIT sortRoleChanged(sortOrder);
         invalidateSorting();
     }
 }
 
 void ResourcesProxyModel::setSearch(const QString &_searchText)
 {
     // 1-character searches are painfully slow. >= 2 chars are fine, though
     const QString searchText = _searchText.count() <= 1 ? QString() : _searchText;
 
     const bool diff = searchText != m_filters.search;
 
     if (diff) {
         m_filters.search = searchText;
         m_sortByRelevancy = !searchText.isEmpty();
         invalidateFilter();
         Q_EMIT searchChanged(m_filters.search);
     }
 }
 
 void ResourcesProxyModel::removeDuplicates(QVector<AbstractResource *>& resources)
 {
     const auto cab = ResourcesModel::global()->currentApplicationBackend();
     QHash<QString, QVector<AbstractResource *>::iterator> storedIds;
     for(auto it = m_displayedResources.begin(); it != m_displayedResources.end(); ++it)
     {
         const auto appstreamid = (*it)->appstreamId();
         if (appstreamid.isEmpty()) {
             continue;
         }
         auto at = storedIds.find(appstreamid);
         if (at == storedIds.end()) {
             storedIds[appstreamid] = it;
         } else {
             qWarning() << "We should have sanitized the displayed resources. There is a bug";
             Q_UNREACHABLE();
         }
     }
 
     QHash<QString, QVector<AbstractResource *>::iterator> ids;
     for(auto it = resources.begin(); it != resources.end(); )
     {
         const auto appstreamid = (*it)->appstreamId();
         if (appstreamid.isEmpty()) {
             ++it;
             continue;
         }
         auto at = storedIds.find(appstreamid);
         if (at == storedIds.end()) {
             auto at = ids.find(appstreamid);
             if (at == ids.end()) {
                 ids[appstreamid] = it;
                 ++it;
             } else {
                 if ((*it)->backend() == cab) {
                     qSwap(*it, **at);
                 }
                 it = resources.erase(it);
             }
         } else {
             if ((*it)->backend() == cab) {
                 **at = *it;
                 auto pos = index(*at - m_displayedResources.begin(), 0);
                 dataChanged(pos, pos);
             }
             it = resources.erase(it);
         }
     }
 }
 
 void ResourcesProxyModel::addResources(const QVector<AbstractResource *>& _res)
 {
     auto res = _res;
     m_filters.filterJustInCase(res);
 
     if (res.isEmpty())
         return;
 
     if (!m_filters.allBackends) {
         removeDuplicates(res);
     }
     if (!m_sortByRelevancy)
         qSort(res.begin(), res.end(), [this](AbstractResource* res, AbstractResource* res2){ return lessThan(res, res2); });
 
     sortedInsertion(res);
     fetchSubcategories();
 }
 
 void ResourcesProxyModel::invalidateSorting()
 {
     if (m_displayedResources.isEmpty())
         return;
 
     if (!m_sortByRelevancy) {
         beginResetModel();
         qSort(m_displayedResources.begin(), m_displayedResources.end(), [this](AbstractResource* res, AbstractResource* res2){ return lessThan(res, res2); });
         endResetModel();
     }
 }
 
 QString ResourcesProxyModel::lastSearch() const
 {
     return m_filters.search;
 }
 
 void ResourcesProxyModel::setOriginFilter(const QString &origin)
 {
     if (origin == m_filters.origin)
         return;
 
     m_filters.origin = origin;
 
     invalidateFilter();
 }
 
 QString ResourcesProxyModel::originFilter() const
 {
     return m_filters.origin;
 }
 
 void ResourcesProxyModel::setFiltersFromCategory(Category *category)
 {
     if(category==m_filters.category)
         return;
 
     m_filters.category = category;
     invalidateFilter();
     emit categoryChanged();
 }
 
 void ResourcesProxyModel::fetchSubcategories()
 {
     auto cats = (m_filters.category ? m_filters.category->subCategories() : CategoryModel::global()->rootCategories()).toList().toSet();
 
     const int count = rowCount();
     QSet<Category*> done;
     for (int i=0; i<count && !cats.isEmpty(); ++i) {
         AbstractResource* res = m_displayedResources[i];
         const auto found = res->categoryObjects(cats.toList().toVector());
         done.unite(found);
         cats.subtract(found);
     }
 
     const QVariantList ret = kTransform<QVariantList>(done, [](Category* cat) { return QVariant::fromValue<QObject*>(cat); });
     if (ret != m_subcategories) {
         m_subcategories = ret;
         Q_EMIT subcategoriesChanged(m_subcategories);
     }
 }
 
 QVariantList ResourcesProxyModel::subcategories() const
 {
     return m_subcategories;
 }
 
 void ResourcesProxyModel::invalidateFilter()
 {
     if (!m_setup || ResourcesModel::global()->backends().isEmpty()) {
         return;
     }
 
     if (m_currentStream) {
         qWarning() << "last stream isn't over yet" << m_filters << this;
         delete m_currentStream;
     }
 
     m_currentStream = ResourcesModel::global()->search(m_filters);
+    Q_EMIT busyChanged(true);
 
     if (!m_displayedResources.isEmpty()) {
         beginResetModel();
         m_displayedResources.clear();
         endResetModel();
     }
 
     connect(m_currentStream, &AggregatedResultsStream::resourcesFound, this, &ResourcesProxyModel::addResources);
     connect(m_currentStream, &AggregatedResultsStream::finished, this, [this]() {
         m_currentStream = nullptr;
         Q_EMIT busyChanged(false);
     });
-    Q_EMIT busyChanged(true);
 }
 
 int ResourcesProxyModel::rowCount(const QModelIndex& parent) const
 {
     return parent.isValid() ? 0 : m_displayedResources.count();
 }
 
 bool ResourcesProxyModel::lessThan(AbstractResource* leftPackage, AbstractResource* rightPackage) const
 {
     auto role = m_sortRole;
     Qt::SortOrder order = m_sortOrder;
     QVariant leftValue;
     QVariant rightValue;
     //if we're comparing two equal values, we want the model sorted by application name
     if(role != NameRole) {
         leftValue = roleToValue(leftPackage, role);
         rightValue = roleToValue(rightPackage, role);
 
         if (leftValue == rightValue) {
             role = NameRole;
             order = Qt::DescendingOrder;
         }
     }
 
     bool ret;
     if(role == NameRole) {
         ret = leftPackage->nameSortKey().compare(rightPackage->nameSortKey()) < 0;
     } else if(role == CanUpgrade) {
         ret = leftValue.toBool();
     } else {
         ret = leftValue < rightValue;
     }
     return ret != (order != Qt::AscendingOrder);
 }
 
 Category* ResourcesProxyModel::filteredCategory() const
 {
     return m_filters.category;
 }
 
 void ResourcesProxyModel::setStateFilter(AbstractResource::State s)
 {
     if (s != m_filters.state) {
         m_filters.state = s;
         invalidateFilter();
         emit stateFilterChanged();
     }
 }
 
 AbstractResource::State ResourcesProxyModel::stateFilter() const
 {
     return m_filters.state;
 }
 
 QString ResourcesProxyModel::mimeTypeFilter() const
 {
     return m_filters.mimetype;
 }
 
 void ResourcesProxyModel::setMimeTypeFilter(const QString& mime)
 {
     if (m_filters.mimetype != mime) {
         m_filters.mimetype = mime;
         invalidateFilter();
     }
 }
 
 QString ResourcesProxyModel::extends() const
 {
     return m_filters.extends;
 }
 
 void ResourcesProxyModel::setExtends(const QString& extends)
 {
     if (m_filters.extends != extends) {
         m_filters.extends = extends;
         invalidateFilter();
     }
 }
 
 QUrl ResourcesProxyModel::resourcesUrl() const
 {
     return m_filters.resourceUrl;
 }
 
 void ResourcesProxyModel::setResourcesUrl(const QUrl& resourcesUrl)
 {
     if (m_filters.resourceUrl != resourcesUrl) {
         m_filters.resourceUrl = resourcesUrl;
         invalidateFilter();
     }
 }
 
 bool ResourcesProxyModel::allBackends() const
 {
     return m_filters.allBackends;
 }
 
 void ResourcesProxyModel::setAllBackends(bool allBackends)
 {
     m_filters.allBackends = allBackends;
 }
 
 QVariant ResourcesProxyModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     AbstractResource* const resource = m_displayedResources[index.row()];
     return roleToValue(resource, role);
 }
 
 QVariant ResourcesProxyModel::roleToValue(AbstractResource* resource, int role) const
 {
     switch(role) {
         case ApplicationRole:
             return qVariantFromValue<QObject*>(resource);
         case RatingPointsRole:
         case RatingRole:
         case RatingCountRole:
         case SortableRatingRole: {
             Rating* const rating = resource->rating();
             const int idx = Rating::staticMetaObject.indexOfProperty(roleNames().value(role).constData());
             Q_ASSERT(idx >= 0);
             auto prop = Rating::staticMetaObject.property(idx);
             if (rating)
                 return prop.read(rating);
             else {
                 QVariant val(0);
                 val.convert(prop.type());
                 return val;
             }
         }
         case Qt::DecorationRole:
         case Qt::DisplayRole:
         case Qt::StatusTipRole:
         case Qt::ToolTipRole:
             return QVariant();
         default: {
             QByteArray roleText = roleNames().value(role);
             if(Q_UNLIKELY(roleText.isEmpty())) {
                 qDebug() << "unsupported role" << role;
                 return {};
             }
             static const QMetaObject* m = &AbstractResource::staticMetaObject;
             int propidx = roleText.isEmpty() ? -1 : m->indexOfProperty(roleText.constData());
 
             if(Q_UNLIKELY(propidx < 0)) {
                 qWarning() << "unknown role:" << role << roleText;
                 return QVariant();
             } else
                 return m->property(propidx).read(resource);
         }
     }
 }
 
 void ResourcesProxyModel::sortedInsertion(const QVector<AbstractResource*> & resources)
 {
     Q_ASSERT(!resources.isEmpty());
     if (m_sortByRelevancy || m_displayedResources.isEmpty()) {
         int rows = rowCount();
         beginInsertRows({}, rows, rows+resources.count()-1);
         m_displayedResources += resources;
         endInsertRows();
         return;
     }
 
     for(auto resource: resources) {
         const auto finder = [this](AbstractResource* resource, AbstractResource* res){ return lessThan(resource, res); };
         const auto it = std::upper_bound(m_displayedResources.constBegin(), m_displayedResources.constEnd(), resource, finder);
         const auto newIdx = it == m_displayedResources.constEnd() ? m_displayedResources.count() : (it - m_displayedResources.constBegin());
 
         if (it != m_displayedResources.constEnd() && *it == resource)
             continue;
 
         beginInsertRows({}, newIdx, newIdx);
         m_displayedResources.insert(newIdx, resource);
         endInsertRows();
     }
 }
 
 void ResourcesProxyModel::refreshResource(AbstractResource* resource, const QVector<QByteArray>& properties)
 {
     const auto residx = m_displayedResources.indexOf(resource);
     if (residx<0) {
         if (!m_sortByRelevancy && m_filters.shouldFilter(resource)) {
             sortedInsertion({resource});
         }
         return;
     }
 
     if (!m_filters.shouldFilter(resource)) {
         beginRemoveRows({}, residx, residx);
         m_displayedResources.removeAt(residx);
         endRemoveRows();
         return;
     }
 
     const QModelIndex idx = index(residx, 0);
     Q_ASSERT(idx.isValid());
     const auto roles = propertiesToRoles(properties);
     if (roles.contains(m_sortRole)) {
         beginRemoveRows({}, residx, residx);
         m_displayedResources.removeAt(residx);
         endRemoveRows();
 
         sortedInsertion({resource});
     } else
         emit dataChanged(idx, idx, roles);
 }
 
 void ResourcesProxyModel::removeResource(AbstractResource* resource)
 {
     const auto residx = m_displayedResources.indexOf(resource);
     if (residx < 0)
         return;
     beginRemoveRows({}, residx, residx);
     m_displayedResources.removeAt(residx);
     endRemoveRows();
 }
 
 void ResourcesProxyModel::refreshBackend(AbstractResourcesBackend* backend, const QVector<QByteArray>& properties)
 {
     auto roles = propertiesToRoles(properties);
     const int count = m_displayedResources.count();
 
     bool found = false;
 
     for(int i = 0; i<count; ++i) {
         if (backend != m_displayedResources[i]->backend())
             continue;
 
         int j = i+1;
         for(; j<count && backend == m_displayedResources[j]->backend(); ++j)
         {}
 
         Q_EMIT dataChanged(index(i, 0), index(j-1, 0), roles);
         i = j;
         found = true;
     }
 
     if (found && properties.contains(m_roles.value(m_sortRole))) {
         invalidateSorting();
     }
 }
 
 QVector<int> ResourcesProxyModel::propertiesToRoles(const QVector<QByteArray>& properties) const
 {
     QVector<int> roles = kTransform<QVector<int>>(properties, [this](const QByteArray& arr) { return roleNames().key(arr, -1); });
     roles.removeAll(-1);
     return roles;
 }
 
 int ResourcesProxyModel::indexOf(AbstractResource* res)
 {
     return m_displayedResources.indexOf(res);
 }
 
 AbstractResource * ResourcesProxyModel::resourceAt(int row) const
 {
     return m_displayedResources[row];
 }