Merge lp:~stolowski/unity-scopes-shell/favorite-scopes into lp:unity-scopes-shell

[Paweł Stołowski]

Support scope favouriting.

Support scope favouriting.

Note: the only way to test it atm is to update gsettings key, e.g.

gsettings set com.canonical.Unity.Dash favorite-scopes "['scope://clickscope', 'scope://musicaggregator', 'scope://videoaggregator', 'scope://com.ubuntu.scopes.youtube_youtube', 'scope://com.canonical.scopes.amazon']"

The change should be reflected in the overview ("Favorites") and in the Dash (cards of available scopes).

[Pete Woods (pete-woods)]

A quick question before reading in detail. Do the tests mess around with the your real settings for the favourite scopes?

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:140
http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-ci/198/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-amd64-ci/95
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/95
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/95/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-i386-ci/95

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-shell-ci/198/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

> A quick question before reading in detail. Do the tests mess around with the
> your real settings for the favourite scopes?

No, the tests use a gsettings memory backend and the intention of that is to use a temporary value for the duration of the tests.

[Michał Sawicz (saviq)]

Looking good, few minor comments.

All in all I feel like this required too much effort... Especially how you have to maintain two models :/

We should consider:
a) making the Scopes model a model canned queries, with dash requesting Scope objects as needed
b) using the same model for overview favorites and Scopes

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:144
http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-ci/201/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-amd64-ci/98
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/98
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/98/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-i386-ci/98

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-shell-ci/201/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

Ok, pushed a bunch of fixes and added comments inline.

As discussed on IRC, (a) and (b) suggested above are correct observations, but they require more refactoring in the existing code, so it's fot later.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:145
http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-ci/202/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-amd64-ci/99
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/99/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-i386-ci/99

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-shell-ci/202/rebuild

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

I seem to be losing the scope too early when I unfavorite it, causing the transition to be quite jarring :/

We'll need to defer destroying them for a while, or maybe move ownership to QML. Or stop supplying scopes in the model and relying on getScope() instead.

review: Needs Information

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:146
http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-ci/204/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-amd64-ci/101
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/101
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/101/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-i386-ci/101

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-shell-ci/204/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

+1, thanks!

review: Approve

[Albert Astals Cid (aacid)]

Michał approved the other branch, this one adds r147 that looks good

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:147
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~stolowski/unity-scopes-shell/favorite-scopes/+merge/232050/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-ci/207/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-amd64-ci/104/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-armhf-ci/104/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-utopic-i386-ci/104/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-shell-ci/207/rebuild

review: Needs Fixing (continuous-integration)

[lp:~stolowski/unity-scopes-shell/favorite-scopes]

149. By Paweł Stołowski on 2014-08-25

Fix test failure.

=== modified file 'debian/control'
--- debian/control	2014-08-14 15:31:11 +0000
+++ debian/control	2014-08-25 17:04:42 +0000
@@ -4,7 +4,7 @@
 Build-Depends: cmake,
                debhelper (>= 9),
                libunity-api-dev (>= 7.88),
-               libunity-scopes-dev (>= 0.6.2~),
+               libunity-scopes-dev (>= 0.6.3~),
                libgsettings-qt-dev (>= 0.1),
                libqtdbustest1-dev (>= 0.2),
                libqtdbusmock1-dev (>= 0.2),
@@ -15,6 +15,7 @@
                qtdeclarative5-dev,
                qtdeclarative5-dev-tools,
                qtdeclarative5-qtquick2-plugin,
+               unity-schemas (>= 7.3.1),
 Standards-Version: 3.9.5
 Maintainer: Ubuntu Developers <[e-mail]>
 Homepage: https://launchpad.net/unity-scopes-shell
@@ -30,6 +31,7 @@
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+         unity-schemas (>= 7.3.1),
 Provides: unity-scopes-impl,
           unity-scopes-impl-0,
           unity-scopes-impl-1,
 
=== modified file 'src/Unity/CMakeLists.txt'
--- src/Unity/CMakeLists.txt	2014-08-14 15:31:11 +0000
+++ src/Unity/CMakeLists.txt	2014-08-25 17:04:42 +0000
@@ -3,7 +3,7 @@
 
 # Dependencies
 pkg_check_modules(SCOPES_API REQUIRED unity-shell-scopes=4)
-pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.6.2)
+pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.6.3)
 pkg_check_modules(GSETTINGSQT REQUIRED gsettings-qt)
 pkg_check_modules(UBUNTU_LOCATION_SERVICE REQUIRED ubuntu-location-service)
 
 
=== modified file 'src/Unity/overviewcategories.cpp'
--- src/Unity/overviewcategories.cpp	2014-07-22 13:49:50 +0000
+++ src/Unity/overviewcategories.cpp	2014-08-25 17:04:42 +0000
@@ -53,7 +53,7 @@
     , m_isSurfacing(true)
 {
     m_allScopes.reset(new OverviewResultsModel(this));
-    m_favouriteScopes.reset(new OverviewResultsModel(this));
+    m_favoriteScopes.reset(new OverviewResultsModel(this));
 
     m_surfaceCategories.append(QSharedPointer<ScopesCategoryData>(new ScopesCategoryData("favorites", CATEGORY_JSON)));
     m_surfaceCategories.append(QSharedPointer<ScopesCategoryData>(new ScopesCategoryData("all", CATEGORY_JSON)));
@@ -84,10 +84,10 @@
     QModelIndex changedIndex(index(1));
     dataChanged(changedIndex, changedIndex, roles);
 }
- 
-void OverviewCategories::setFavouriteScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes)
+
+void OverviewCategories::setFavoriteScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes)
 {
-    m_favouriteScopes->setResults(scopes);
+    m_favoriteScopes->setResults(scopes);
 
     if (!m_isSurfacing) return;
 
@@ -98,6 +98,11 @@
     dataChanged(changedIndex, changedIndex, roles);
 }
 
+void OverviewCategories::updateFavoriteScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes)
+{
+    m_favoriteScopes->setResults(scopes);
+}
+
 int OverviewCategories::rowCount(const QModelIndex& parent) const
 {
     if (m_isSurfacing) {
@@ -115,7 +120,7 @@
     }
 
     ScopesCategoryData* catData = m_surfaceCategories.at(index.row()).data();
-    OverviewResultsModel* results = index.row() == 0 ? m_favouriteScopes.data() : m_allScopes.data();
+    OverviewResultsModel* results = index.row() == 0 ? m_favoriteScopes.data() : m_allScopes.data();
 
     switch (role) {
         case RoleCategoryId:
 
=== modified file 'src/Unity/overviewcategories.h'
--- src/Unity/overviewcategories.h	2014-07-18 09:21:24 +0000
+++ src/Unity/overviewcategories.h	2014-08-25 17:04:42 +0000
@@ -45,14 +45,15 @@
     int rowCount(const QModelIndex& parent = QModelIndex()) const override;
 
     void setAllScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes);
-    void setFavouriteScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes);
+    void setFavoriteScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes);
+    void updateFavoriteScopes(const QList<unity::scopes::ScopeMetadata::SPtr>& scopes);
 
 private:
     bool m_isSurfacing;
 
     QList<QSharedPointer<ScopesCategoryData>> m_surfaceCategories;
     QScopedPointer<OverviewResultsModel> m_allScopes;
-    QScopedPointer<OverviewResultsModel> m_favouriteScopes;
+    QScopedPointer<OverviewResultsModel> m_favoriteScopes;
 };
 
 } // namespace scopes_ng
 
=== modified file 'src/Unity/overviewresults.cpp'
--- src/Unity/overviewresults.cpp	2014-08-25 17:04:42 +0000
+++ src/Unity/overviewresults.cpp	2014-08-25 17:04:42 +0000
@@ -25,6 +25,7 @@
 #include "utils.h"
 
 #include <unity/scopes/Result.h>
+#include <QSet>
 
 namespace scopes_ng {
 
@@ -68,9 +69,50 @@
 
 void OverviewResultsModel::setResults(const QList<unity::scopes::ScopeMetadata::SPtr>& results)
 {
-    beginResetModel();
-    m_results = results;
-    endResetModel();
+    if (m_results.empty()) {
+        beginResetModel();
+        m_results = results;
+        endResetModel();
+        Q_EMIT countChanged();
+        return;
+    }
+
+    QSet<QString> newResult;
+    for (auto const res: results) {
+        newResult.insert(QString::fromStdString(res->scope_id()));
+    }
+
+    // itearate over old results, remove rows that are not present in new results
+    int row = 0;
+    for (auto it = m_results.begin(); it != m_results.end();)
+    {
+        if (!newResult.contains(QString::fromStdString((*it)->scope_id()))) {
+            beginRemoveRows(QModelIndex(), row, row);
+            it = m_results.erase(it);
+            endRemoveRows();
+        } else {
+            ++it;
+            ++row;
+        }
+    }
+
+    QSet<QString> oldResult;
+    for (auto const res: m_results) {
+        oldResult.insert(QString::fromStdString(res->scope_id()));
+    }
+
+    // iterate over new results, insert rows if not in previous model
+    row = 0;
+    for (auto const newRes: results)
+    {
+        if (!oldResult.contains(QString::fromStdString(newRes->scope_id())))
+        {
+            beginInsertRows(QModelIndex(), row, row);
+            m_results.insert(row, newRes);
+            endInsertRows();
+        }
+        ++row;
+    }
     Q_EMIT countChanged();
 }
 
 
=== modified file 'src/Unity/overviewscope.cpp'
--- src/Unity/overviewscope.cpp	2014-08-01 11:43:58 +0000
+++ src/Unity/overviewscope.cpp	2014-08-25 17:04:42 +0000
@@ -66,11 +66,11 @@
     }
 
     QMap<QString, scopes::ScopeMetadata::SPtr> allMetadata = m_scopesInstance->getAllMetadata();
-    QList<scopes::ScopeMetadata::SPtr> favourites;
+    QList<scopes::ScopeMetadata::SPtr> favorites;
     Q_FOREACH(QString id, m_scopesInstance->getFavoriteIds()) {
         auto it = allMetadata.find(id);
         if (it != allMetadata.end()) {
-            favourites.append(it.value());
+            favorites.append(it.value());
         }
     }
 
@@ -88,7 +88,7 @@
 
     // FIXME: filter invisible scopes?
     categories->setAllScopes(allScopes);
-    categories->setFavouriteScopes(favourites);
+    categories->setFavoriteScopes(favorites);
 }
 
 QString OverviewScope::id() const
@@ -106,6 +106,27 @@
     }
 }
 
+void OverviewScope::updateFavorites(const QStringList& favorites)
+{
+    QList<scopes::ScopeMetadata::SPtr> favs;
+    auto allMetadata = m_scopesInstance->getAllMetadata();
+    for (auto const id: favorites)
+    {
+        auto it = allMetadata.find(id);
+        if (it != allMetadata.end()) {
+            favs.append(it.value());
+        }
+    }
+
+    OverviewCategories* categories = qobject_cast<OverviewCategories*>(m_categories.data());
+    if (!categories) {
+        qWarning("Unable to cast m_categories to OverviewCategories");
+        return;
+    }
+
+    categories->updateFavoriteScopes(favs);
+}
+
 void OverviewScope::dispatchSearch()
 {
     OverviewCategories* categories = qobject_cast<OverviewCategories*>(m_categories.data());
 
=== modified file 'src/Unity/overviewscope.h'
--- src/Unity/overviewscope.h	2014-08-01 11:43:58 +0000
+++ src/Unity/overviewscope.h	2014-08-25 17:04:42 +0000
@@ -38,6 +38,8 @@
 
     void dispatchSearch() override;
 
+    void updateFavorites(const QStringList& favorites);
+
     unity::scopes::ScopeProxy proxy_for_result(unity::scopes::Result::SPtr const& result) const override;
 
 private Q_SLOTS:
 
=== modified file 'src/Unity/scope.cpp'
--- src/Unity/scope.cpp	2014-08-18 18:41:23 +0000
+++ src/Unity/scope.cpp	2014-08-25 17:04:42 +0000
@@ -74,6 +74,7 @@
     , m_delayedClear(false)
     , m_hasNavigation(false)
     , m_hasAltNavigation(false)
+    , m_favorite(false)
     , m_searchController(new CollectionController)
     , m_activationController(new CollectionController)
     , m_status(Status::Okay)
@@ -753,7 +754,7 @@
 
 bool Scope::favorite() const
 {
-    return true;
+    return m_favorite;
 }
 
 QString Scope::shortcut() const
@@ -993,9 +994,12 @@
 
 void Scope::setFavorite(const bool value)
 {
-    Q_UNUSED(value);
-
-    qWarning("Unimplemented: %s", __func__);
+    if (value != m_favorite)
+    {
+        m_favorite = value;
+        Q_EMIT favoriteChanged(value);
+        m_scopesInstance->setFavorite(id(), value);
+    }
 }
 
 void Scope::activate(QVariant const& result_var)
 
=== modified file 'src/Unity/scope.h'
--- src/Unity/scope.h	2014-08-13 08:36:17 +0000
+++ src/Unity/scope.h	2014-08-25 17:04:42 +0000
@@ -111,6 +111,8 @@
 
     virtual bool event(QEvent* ev) override;
 
+    Q_PROPERTY(bool favorite READ favorite WRITE setFavorite NOTIFY favoriteChanged)
+
     /* getters */
     QString id() const override;
     QString name() const override;
@@ -162,6 +164,7 @@
 
 Q_SIGNALS:
     void resultsDirtyChanged();
+    void favoriteChanged(bool);
 
 private Q_SLOTS:
     void flushUpdates();
@@ -207,6 +210,7 @@
     bool m_delayedClear;
     bool m_hasNavigation;
     bool m_hasAltNavigation;
+    bool m_favorite;
 
     std::unique_ptr<CollectionController> m_searchController;
     std::unique_ptr<CollectionController> m_activationController;
 
=== modified file 'src/Unity/scopes.cpp'
--- src/Unity/scopes.cpp	2014-08-01 13:12:54 +0000
+++ src/Unity/scopes.cpp	2014-08-25 17:04:42 +0000
@@ -82,6 +82,7 @@
 }
 
 int Scopes::LIST_DELAY = -1;
+const int Scopes::SCOPE_DELETE_DELAY = 3;
 
 class Scopes::Priv : public QObject {
     Q_OBJECT
@@ -111,6 +112,12 @@
 
     QDBusConnection::sessionBus().connect(QString(), QString("/com/canonical/unity/scopes"), QString("com.canonical.unity.scopes"), QString("InvalidateResults"), this, SLOT(invalidateScopeResults(QString)));
 
+    m_dashSettings = QGSettings::isSchemaInstalled("com.canonical.Unity.Dash") ? new QGSettings("com.canonical.Unity.Dash", QByteArray(), this) : nullptr;
+    if (m_dashSettings)
+    {
+        QObject::connect(m_dashSettings, &QGSettings::changed, this, &Scopes::dashSettingsChanged);
+    }
+
     m_overviewScope = new OverviewScope(this);
     m_locationService.reset(new UbuntuLocationService());
 }
@@ -159,31 +166,8 @@
                             std::bind(&Scopes::Priv::safeInvalidateScopeResults,
                                       m_priv.get(), SCOPES_SCOPE_ID))));
 
-    // FIXME: use a dconf setting for this
-    QByteArray enabledScopes = qgetenv("UNITY_SCOPES_LIST");
-
     beginResetModel();
 
-    if (!enabledScopes.isNull()) {
-        QList<QByteArray> scopeList = enabledScopes.split(';');
-        for (int i = 0; i < scopeList.size(); i++) {
-            std::string scope_name(scopeList[i].constData());
-            auto it = scopes.find(scope_name);
-            if (it != scopes.end()) {
-                auto scope = new Scope(this);
-                scope->setScopeData(it->second);
-                m_scopes.append(scope);
-            }
-        }
-    } else {
-        // add all the scopes
-        for (auto it = scopes.begin(); it != scopes.end(); ++it) {
-            auto scope = new Scope(this);
-            scope->setScopeData(it->second);
-            m_scopes.append(scope);
-        }
-    }
-
     // HACK! deal with the overview scope
     {
         auto it = scopes.find(SCOPES_SCOPE_ID);
@@ -199,6 +183,7 @@
         m_cachedMetadata[QString::fromStdString(it->first)] = std::make_shared<unity::scopes::ScopeMetadata>(it->second);
     }
 
+    processFavoriteScopes();
     endResetModel();
 
     m_loaded = true;
@@ -210,6 +195,104 @@
     m_listThread = nullptr;
 }
 
+void Scopes::processFavoriteScopes()
+{
+    //
+    // read the favoriteScopes array value from gsettings.
+    // process it and turn its values into scope ids.
+    // create new Scope objects or remove existing according to the list of favorities.
+    // notify about scopes model changes accordingly.
+    if (m_dashSettings) {
+        QStringList newFavorites;
+        QSet<QString> favScopesLut;
+        for (auto const& fv: m_dashSettings->get("favoriteScopes").toList())
+        {
+            try
+            {
+                auto const query = unity::scopes::CannedQuery::from_uri(fv.toString().toStdString());
+                const QString id = QString::fromStdString(query.scope_id());
+                newFavorites.push_back(id);
+                favScopesLut.insert(id);
+            }
+            catch (const InvalidArgumentException &e)
+            {
+                qWarning() << "Invalid canned query '" << fv.toString() << "'" << QString::fromStdString(e.what());
+            }
+        }
+
+        // this prevents further processing if we get called back when calling scope->setFavorite() below
+        if (m_favoriteScopes == newFavorites)
+            return;
+
+        m_favoriteScopes = newFavorites;
+
+        QSet<QString> oldScopes;
+        int row = 0;
+        // remove un-favorited scopes
+        for (auto it = m_scopes.begin(); it != m_scopes.end();)
+        {
+            if (!favScopesLut.contains((*it)->id()))
+            {
+                beginRemoveRows(QModelIndex(), row, row);
+                (*it)->setFavorite(false);
+                //
+                // we need to delay actual deletion of Scope object so that shell can animate it
+                QTimer::singleShot(1000 * SCOPE_DELETE_DELAY, (*it), SLOT(deleteLater));
+                it = m_scopes.erase(it);
+                endRemoveRows();
+            }
+            else
+            {
+                oldScopes.insert((*it)->id());
+                ++it;
+                ++row;
+            }
+        }
+
+        // add new favorites
+        row = 0;
+        for (auto favIt = m_favoriteScopes.begin(); favIt != m_favoriteScopes.end(); )
+        {
+            auto const fav = *favIt;
+            if (!oldScopes.contains(fav))
+            {
+                auto it = m_cachedMetadata.find(fav);
+                if (it != m_cachedMetadata.end())
+                {
+                    auto scope = new Scope(this);
+                    scope->setScopeData(*(it.value()));
+                    scope->setFavorite(true);
+                    beginInsertRows(QModelIndex(), row, row);
+                    m_scopes.insert(row, scope);
+                    endInsertRows();
+                }
+                else
+                {
+                    qWarning() << "No such scope:" << fav;
+                    favIt = m_favoriteScopes.erase(favIt);
+                    continue;
+                }
+            }
+            ++row;
+            ++favIt;
+        }
+    }
+}
+
+void Scopes::dashSettingsChanged(QString const& key)
+{
+    if (key != "favoriteScopes") {
+        return;
+    }
+
+    processFavoriteScopes();
+
+    if (m_overviewScope)
+    {
+        m_overviewScope->updateFavorites(m_favoriteScopes);
+    }
+}
+
 void Scopes::refreshFinished()
 {
     ScopeListWorker* thread = qobject_cast<ScopeListWorker*>(sender());
@@ -288,13 +371,39 @@
 
 QStringList Scopes::getFavoriteIds() const
 {
-    QStringList ids;
-
-    Q_FOREACH(Scope* scope, m_scopes) {
-        ids << scope->id();
+    return m_favoriteScopes;
+}
+
+void Scopes::setFavorite(QString const& scopeId, bool value)
+{
+    if (m_dashSettings)
+    {
+        QStringList cannedQueries;
+        bool changed = false;
+
+        for (auto const& fav: m_favoriteScopes)
+        {
+            if (value == false && fav == scopeId) {
+                changed = true;
+                continue; // skip it
+            }
+            // TODO: use CannedQuery::to_uri() when we really support them
+            const QString query = "scope://" + fav;
+            cannedQueries.push_back(query);
+        }
+
+        if (value && !m_favoriteScopes.contains(scopeId)) {
+            const QString query = "scope://" + scopeId;
+            cannedQueries.push_back(query);
+            changed = true;
+        }
+
+        if (changed) {
+            // update gsettings entry
+            // note: this will trigger notification, so that new favorites are processed by processFavoriteScopes
+            m_dashSettings->set("favoriteScopes", QVariant(cannedQueries));
+        }
     }
-
-    return ids;
 }
 
 QMap<QString, unity::scopes::ScopeMetadata::SPtr> Scopes::getAllMetadata() const
 
=== modified file 'src/Unity/scopes.h'
--- src/Unity/scopes.h	2014-08-01 13:12:54 +0000
+++ src/Unity/scopes.h	2014-08-25 17:04:42 +0000
@@ -29,6 +29,7 @@
 #include <QThread>
 #include <QStringList>
 #include <QSharedPointer>
+#include <QGSettings>
 
 #include <unity/scopes/Runtime.h>
 #include <unity/scopes/Registry.h>
@@ -40,6 +41,7 @@
 {
 
 class Scope;
+class OverviewScope;
 
 class Q_DECL_EXPORT Scopes : public unity::shell::scopes::ScopesInterface
 {
@@ -58,6 +60,7 @@
     unity::scopes::ScopeMetadata::SPtr getCachedMetadata(QString const& scopeId) const;
     QMap<QString, unity::scopes::ScopeMetadata::SPtr> getAllMetadata() const;
     QStringList getFavoriteIds() const;
+    void setFavorite(QString const& scopeId, bool value);
 
     void refreshScopeMetadata();
 
@@ -71,6 +74,8 @@
     void metadataRefreshed();
 
 private Q_SLOTS:
+    void dashSettingsChanged(QString const &key);
+    void processFavoriteScopes();
     void populateScopes();
     void discoveryFinished();
     void refreshFinished();
@@ -78,11 +83,14 @@
 
 private:
     static int LIST_DELAY;
+    static const int SCOPE_DELETE_DELAY;
     class Priv;
 
     QList<Scope*> m_scopes;
+    QStringList m_favoriteScopes;
+    QGSettings* m_dashSettings;
     QMap<QString, unity::scopes::ScopeMetadata::SPtr> m_cachedMetadata;
-    Scope* m_overviewScope;
+    OverviewScope* m_overviewScope;
     QThread* m_listThread;
     bool m_loaded;
 
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-08-13 17:16:21 +0000
+++ tests/CMakeLists.txt	2014-08-25 17:04:42 +0000
@@ -36,6 +36,7 @@
         add_executable(${_test}Exec
                        ${_test}.cpp 
                        ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/PreviewModelInterface.h
+                       ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/ScopeInterface.h
                       )
         qt5_use_modules(${_test}Exec Test Core Qml DBus)
         set_tests_properties(test${CLASSNAME}${_test}
@@ -57,6 +58,7 @@
 
 run_tests(
     departmentstest
+    favoritestest
     locationtest
     overviewtest
     previewtest
 
=== modified file 'tests/departmentstest.cpp'
--- tests/departmentstest.cpp	2014-08-04 15:06:55 +0000
+++ tests/departmentstest.cpp	2014-08-25 17:04:42 +0000
@@ -64,6 +64,10 @@
 
     void init()
     {
+        QStringList favs;
+        favs << "scope://mock-scope-departments" << "scope://mock-scope-double-nav";
+        setFavouriteScopes(favs);
+
         m_scopes.reset(new Scopes(nullptr));
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
 
=== added file 'tests/favoritestest.cpp'
--- tests/favoritestest.cpp	1970-01-01 00:00:00 +0000
+++ tests/favoritestest.cpp	2014-08-25 17:04:42 +0000
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * 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; version 3.
+ *
+ * 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/>.
+ *
+ * Authors:
+ *  Pawel Stolowski <[e-mail]>
+ */
+
+#include <QObject>
+#include <QTest>
+#include <QScopedPointer>
+#include <QSignalSpy>
+
+#include <scopes.h>
+#include <scope.h>
+#include <overviewresults.h>
+#include <unity/shell/scopes/ScopeInterface.h>
+
+#include "registry-spawner.h"
+#include "test-utils.h"
+
+using namespace scopes_ng;
+using namespace unity::shell::scopes;
+
+class FavoritesTest: public QObject
+{
+    Q_OBJECT
+private:
+    QScopedPointer<Scopes> m_scopes;
+    Scope* m_overviewScope;
+    QScopedPointer<RegistrySpawner> m_registry;
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        m_registry.reset(new RegistrySpawner);
+    }
+
+    void cleanupTestCase()
+    {
+        m_registry.reset();
+    }
+
+    void init()
+    {
+        setFavouriteScopes(QStringList());
+
+        m_scopes.reset(new Scopes(nullptr));
+
+        // no scopes on startup
+        QCOMPARE(m_scopes->rowCount(), 0);
+        QCOMPARE(m_scopes->loaded(), false);
+        QSignalSpy spy(m_scopes.data(), SIGNAL(loadedChanged()));
+
+        // wait till the registry spawns
+        QVERIFY(spy.wait());
+        QCOMPARE(m_scopes->loaded(), true);
+
+        // no scopes after startup, since favorites empty
+        QCOMPARE(m_scopes->rowCount(), 0);
+
+        // get overview scope proxy
+        m_overviewScope = qobject_cast<scopes_ng::Scope*>(m_scopes->overviewScope());
+        QVERIFY(m_overviewScope!= nullptr);
+        m_overviewScope->setActive(true);
+    }
+
+    void testFavoritePropertyUpdates()
+    {
+        QStringList favs;
+        favs << "scope://mock-scope-departments";
+        setFavouriteScopes(favs);
+
+        // should have one scope now
+        QTRY_COMPARE(m_scopes->rowCount(), 1);
+        auto scope1 = qobject_cast<scopes_ng::Scope*>(m_scopes->getScope(QString("mock-scope-departments")));
+        QVERIFY(scope1 != nullptr);
+        QCOMPARE(scope1->favorite(), true);
+
+        favs << "scope://mock-scope-double-nav";
+        setFavouriteScopes(favs);
+
+        // should have two scopes now
+        QTRY_COMPARE(m_scopes->rowCount(), 2);
+        auto scope2 = qobject_cast<scopes_ng::Scope*>(m_scopes->getScope(QString("mock-scope-double-nav")));
+        QVERIFY(scope2 != nullptr);
+        QCOMPARE(scope2->favorite(), true);
+
+        // unfavorite 1st scope
+        QSignalSpy spy(scope1, SIGNAL(favoriteChanged(bool)));
+        scope1->setFavorite(false);
+        QTRY_COMPARE(spy.count(), 1);
+        QTRY_COMPARE(m_scopes->rowCount(), 1);
+        QVERIFY(m_scopes->getScopeById("mock-scope-departments") == nullptr);
+        QCOMPARE(m_scopes->data(m_scopes->index(0), Scopes::RoleId), QVariant(QString("mock-scope-double-nav")));
+
+        // favorite a scope
+        auto overviewScope = m_scopes->overviewScope();
+        QVERIFY(overviewScope != nullptr);
+        connect(overviewScope, &unity::shell::scopes::ScopeInterface::openScope, [](unity::shell::scopes::ScopeInterface* scope) {
+                QCOMPARE(scope->favorite(), false);
+                scope->setFavorite(true);
+        });
+
+        QVERIFY(m_scopes->getScopeById("mock-scope") == nullptr);
+        overviewScope->performQuery("scope://mock-scope");
+        QTRY_VERIFY(m_scopes->getScopeById("mock-scope") != nullptr);
+    }
+
+    void testFavoritesOverviewUpdates()
+    {
+        auto categories = m_overviewScope->categories();
+        QVERIFY(categories->rowCount() > 0);
+        QCOMPARE(categories->data(categories->index(0), Categories::Roles::RoleCategoryId), QVariant(QString("favorites")));
+
+        QVariant results_var = categories->data(categories->index(0), Categories::Roles::RoleResults);
+        QVERIFY(results_var.canConvert<OverviewResultsModel*>());
+        OverviewResultsModel* results = results_var.value<OverviewResultsModel*>();
+        QCOMPARE(results->rowCount(), 0);
+
+        // favorite one scope, check if it appears in the favorites model
+        QStringList favs;
+        favs << "scope://mock-scope-departments";
+        setFavouriteScopes(favs);
+
+        QTRY_COMPARE(results->rowCount(), 1);
+
+        // unfavorite it, verify it disappears from favorites model
+        setFavouriteScopes(QStringList());
+        QTRY_COMPARE(results->rowCount(), 0);
+    }
+
+    void testGSettingsUpdates()
+    {
+        QStringList favs;
+        favs << "scope://mock-scope-departments" << "scope://mock-scope-double-nav";
+        setFavouriteScopes(favs);
+
+        // should have two scopes
+        QTRY_COMPARE(m_scopes->rowCount(), 2);
+        auto scope1 = qobject_cast<scopes_ng::Scope*>(m_scopes->getScope(QString("mock-scope-departments")));
+        QVERIFY(scope1 != nullptr);
+
+        // un-facorite one scope
+        scope1->setFavorite(false);
+        QTRY_COMPARE(getFavoriteScopes().size(), 1);
+        QCOMPARE(getFavoriteScopes().at(0), QString("scope://mock-scope-double-nav"));
+    }
+
+    void cleanup()
+    {
+        m_scopes.reset();
+    }
+};
+
+QTEST_GUILESS_MAIN(FavoritesTest)
+#include <favoritestest.moc>
 
=== modified file 'tests/overviewtest.cpp'
--- tests/overviewtest.cpp	2014-07-31 11:23:44 +0000
+++ tests/overviewtest.cpp	2014-08-25 17:04:42 +0000
@@ -60,6 +60,10 @@
 
     void init()
     {
+        QStringList favs;
+        favs << "scope://mock-scope-departments" << "scope://mock-scope-double-nav";
+        setFavouriteScopes(favs);
+
         m_scopes.reset(new Scopes(nullptr));
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
 
=== modified file 'tests/previewtest.cpp'
--- tests/previewtest.cpp	2014-08-06 08:35:20 +0000
+++ tests/previewtest.cpp	2014-08-25 17:04:42 +0000
@@ -58,6 +58,9 @@
 
     void init()
     {
+        const QStringList favs {"scope://mock-scope-departments", "scope://mock-scope-double-nav", "scope://mock-scope"};
+        setFavouriteScopes(favs);
+
         m_scopes.reset(new Scopes(nullptr));
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
 
=== modified file 'tests/resultstest.cpp'
--- tests/resultstest.cpp	2014-08-14 10:23:34 +0000
+++ tests/resultstest.cpp	2014-08-25 17:04:42 +0000
@@ -104,6 +104,9 @@
 
     void init()
     {
+        const QStringList favs {"scope://mock-scope", "scope://mock-scope-ttl", "scope://mock-scope-info"};
+        setFavouriteScopes(favs);
+
         m_scopes.reset(new Scopes(nullptr));
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
 
=== modified file 'tests/settingsendtoendtest.cpp'
--- tests/settingsendtoendtest.cpp	2014-08-06 08:35:20 +0000
+++ tests/settingsendtoendtest.cpp	2014-08-25 17:04:42 +0000
@@ -26,6 +26,7 @@
 
 #include <unity/shell/scopes/SettingsModelInterface.h>
 
+#include "test-utils.h"
 #include "registry-spawner.h"
 
 using namespace scopes_ng;
@@ -52,6 +53,9 @@
 
     void init()
     {
+        const QStringList favs {"scope://mock-scope-departments", "scope://mock-scope-double-nav", "scope://mock-scope"};
+        setFavouriteScopes(favs);
+
         m_scopes.reset(new Scopes(nullptr));
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
 
=== modified file 'tests/test-utils.h'
--- tests/test-utils.h	2014-07-22 13:49:50 +0000
+++ tests/test-utils.h	2014-08-25 17:04:42 +0000
@@ -98,3 +98,21 @@
 
     return true;
 }
+
+void setFavouriteScopes(const QStringList& cannedQueries)
+{
+    setenv("GSETTINGS_BACKEND", "memory", 1);
+    QGSettings settings("com.canonical.Unity.Dash", QByteArray(), nullptr);
+    settings.set("favoriteScopes", QVariant(cannedQueries));
+}
+
+QStringList getFavoriteScopes()
+{
+    setenv("GSETTINGS_BACKEND", "memory", 1);
+    QGSettings settings("com.canonical.Unity.Dash", QByteArray(), nullptr);
+    QStringList favs;
+    for (auto const favvar: settings.get("favoriteScopes").toList()) {
+        favs.push_back(favvar.toString());
+    }
+    return favs;
+}