Merge lp:~mhr3/unity-scopes-shell/department-support into lp:unity-scopes-shell

[Michal Hruby]

Added support for departments.

Added support for departments. Note that this requires changes to lp:unity-api (https://code.launchpad.net/~unity-team/unity-api/departments/+merge/221241) plus changes to libunity-scopes departments API (present in lp:unity-scopes-api/devel).

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Paweł Stołowski (stolowski)]

review: Needs Fixing

[lp:~mhr3/unity-scopes-shell/department-support]

124. By Michal Hruby on 2014-06-03

Let's not forget to commit this

[Albert Astals Cid (aacid)]

Some small comments over a quick code review.

Will check tests tomorrow.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

My small comments were indeed a "Needs fixing"

review: Needs Fixing

[Albert Astals Cid (aacid)]

Besides my small inline comments from https://code.launchpad.net/%7Emhr3/unity-scopes-shell/department-support/+merge/221883/+index the rest looks nice :)

[Michal Hruby (mhr3)]

Should be all addressed now.

[Michal Hruby (mhr3)]

Eh, in the superseding branch...

Unmerged revisions

=== modified file 'debian/changelog'
--- debian/changelog	2014-05-22 09:46:47 +0000
+++ debian/changelog	2014-06-03 15:51:24 +0000
@@ -1,3 +1,9 @@
+unity-scopes-shell (0.4.8-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Added support for departments
+
+ -- Michal Hruby <[e-mail]>  Tue, 27 May 2014 14:20:15 +0200
+
 unity-scopes-shell (0.4.0+14.10.20140522-0ubuntu1) utopic; urgency=low
 
   [ Albert Astals ]

=== modified file 'debian/control'
--- debian/control	2014-05-22 08:03:59 +0000
+++ debian/control	2014-06-03 15:51:24 +0000
@@ -3,8 +3,8 @@
 Section: libs
 Build-Depends: cmake,
                debhelper (>= 9),
-               libunity-api-dev (>= 7.81),
-               libunity-scopes-dev (>= 0.4.6~),
+               libunity-api-dev (>= 7.82),
+               libunity-scopes-dev (>= 0.4.8~),
                libgsettings-qt-dev (>= 0.1),
                pkg-config,
                qt5-default,

=== modified file 'src/Unity/CMakeLists.txt'
--- src/Unity/CMakeLists.txt	2014-05-22 09:18:45 +0000
+++ src/Unity/CMakeLists.txt	2014-06-03 15:51:24 +0000
@@ -4,7 +4,7 @@
 # Dependencies
 include(FindPkgConfig)
 pkg_check_modules(SCOPES_API REQUIRED unity-shell-scopes=1)
-pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.4.0)
+pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.4.8)
 pkg_check_modules(GSETTINGSQT REQUIRED gsettings-qt)
 
 include_directories(
@@ -17,6 +17,8 @@
 set(QMLPLUGIN_SRC
     categories.cpp
     collectors.cpp
+    department.cpp
+    departmentnode.cpp
     previewmodel.cpp
     previewstack.cpp
     previewwidgetmodel.cpp
@@ -29,6 +31,7 @@
     # We need these headers here so moc runs and we get the moc-stuff
     # compiled in, otherwise we miss some symbols
     ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/CategoriesInterface.h
+    ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/DepartmentInterface.h
     ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/PreviewModelInterface.h
     ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/PreviewStackInterface.h
     ${SCOPES_API_INCLUDEDIR}/unity/shell/scopes/PreviewWidgetModelInterface.h

=== modified file 'src/Unity/collectors.cpp'
--- src/Unity/collectors.cpp	2014-03-25 16:34:26 +0000
+++ src/Unity/collectors.cpp	2014-06-03 15:51:24 +0000
@@ -71,15 +71,15 @@
     return m_timer.elapsed();
 }
 
-class ResultCollector: public CollectorBase
+class SearchDataCollector: public CollectorBase
 {
 public:
-    ResultCollector(): CollectorBase()
+    SearchDataCollector(): CollectorBase()
     {
     }
 
     // Returns bool indicating whether this resultset was already posted
-    bool addResult(std::shared_ptr<scopes::CategorisedResult> const& result)
+    bool addResult(scopes::CategorisedResult::SPtr const& result)
     {
         QMutexLocker locker(&m_mutex);
         m_results.append(result);
@@ -87,7 +87,13 @@
         return m_posted;
     }
 
-    Status collect(QList<std::shared_ptr<scopes::CategorisedResult>>& out_results)
+    void setDepartment(scopes::Department::SCPtr const& department)
+    {
+        QMutexLocker locker(&m_mutex);
+        m_rootDepartment = department;
+    }
+
+    Status collect(QList<scopes::CategorisedResult::SPtr>& out_results, scopes::Department::SPtr& rootDepartment)
     {
         Status status;
 
@@ -98,12 +104,14 @@
         }
         status = m_status;
         m_results.swap(out_results);
+        rootDepartment = std::const_pointer_cast<scopes::Department>(m_rootDepartment);
 
         return status;
     }
 
 private:
-    QList<std::shared_ptr<scopes::CategorisedResult>> m_results;
+    QList<scopes::CategorisedResult::SPtr> m_results;
+    scopes::Department::SCPtr m_rootDepartment;
 };
 
 class PreviewDataCollector: public CollectorBase
@@ -214,10 +222,10 @@
     return m_collector->msecsSinceStart();
 }
 
-CollectorBase::Status PushEvent::collectSearchResults(QList<std::shared_ptr<scopes::CategorisedResult>>& out_results)
+CollectorBase::Status PushEvent::collectSearchResults(QList<scopes::CategorisedResult::SPtr>& out_results, scopes::Department::SPtr& rootDepartment)
 {
-    auto collector = std::dynamic_pointer_cast<ResultCollector>(m_collector);
-    return collector->collect(out_results);
+    auto collector = std::dynamic_pointer_cast<SearchDataCollector>(m_collector);
+    return collector->collect(out_results, rootDepartment);
 }
 
 CollectorBase::Status PushEvent::collectPreviewData(scopes::ColumnLayoutList& out_columns, scopes::PreviewWidgetList& out_widgets, QHash<QString, QVariant>& out_data)
@@ -257,9 +265,9 @@
 }
 
 SearchResultReceiver::SearchResultReceiver(QObject* receiver):
-    ScopeDataReceiverBase(receiver, PushEvent::SEARCH, std::shared_ptr<CollectorBase>(new ResultCollector))
+    ScopeDataReceiverBase(receiver, PushEvent::SEARCH, std::shared_ptr<CollectorBase>(new SearchDataCollector))
 {
-    m_collector = collectorAs<ResultCollector>();
+    m_collector = collectorAs<SearchDataCollector>();
 }
 
 // this will be called from non-main thread, (might even be multiple different threads)
@@ -273,6 +281,12 @@
     }
 }
 
+// this will be called from non-main thread, (might even be multiple different threads)
+void SearchResultReceiver::push(scopes::Department::SCPtr const& department)
+{
+    m_collector->setDepartment(department);
+}
+
 // this might be called from any thread (might be main, might be any other thread)
 void SearchResultReceiver::finished(scopes::ListenerBase::Reason reason, std::string const& error_msg)
 {

=== modified file 'src/Unity/collectors.h'
--- src/Unity/collectors.h	2014-03-25 16:34:26 +0000
+++ src/Unity/collectors.h	2014-06-03 15:51:24 +0000
@@ -37,7 +37,7 @@
 namespace scopes_ng
 {
 
-class ResultCollector;
+class SearchDataCollector;
 class PreviewDataCollector;
 class ActivationCollector;
 
@@ -73,7 +73,7 @@
     PushEvent(Type event_type, std::shared_ptr<CollectorBase> collector);
     Type type();
 
-    CollectorBase::Status collectSearchResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>>& out_results);
+    CollectorBase::Status collectSearchResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>>& out_results, unity::scopes::Department::SPtr& rootDepartment);
     CollectorBase::Status collectPreviewData(unity::scopes::ColumnLayoutList& out_columns, unity::scopes::PreviewWidgetList& out_widgets, QHash<QString, QVariant>& out_data);
     CollectorBase::Status collectActivationResponse(std::shared_ptr<unity::scopes::ActivationResponse>& out_response, std::shared_ptr<unity::scopes::Result>& out_result);
 
@@ -104,12 +104,13 @@
 {
 public:
     virtual void push(unity::scopes::CategorisedResult result) override;
+    virtual void push(unity::scopes::Department::SCPtr const& department) override;
     virtual void finished(unity::scopes::ListenerBase::Reason reason, std::string const& error_msg) override;
 
     SearchResultReceiver(QObject* receiver);
 
 private:
-    std::shared_ptr<ResultCollector> m_collector;
+    std::shared_ptr<SearchDataCollector> m_collector;
 };
 
 class PreviewDataReceiver: public unity::scopes::PreviewListenerBase, public ScopeDataReceiverBase

=== added file 'src/Unity/department.cpp'
--- src/Unity/department.cpp	1970-01-01 00:00:00 +0000
+++ src/Unity/department.cpp	2014-06-03 15:51:24 +0000
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Michal Hruby <[e-mail]>
+ *
+ * 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/>.
+ */
+
+#include "department.h"
+
+namespace scopes_ng
+{
+
+using namespace unity;
+
+Department::Department(QObject* parent) :
+    unity::shell::scopes::DepartmentInterface(parent),
+    m_loaded(false),
+    m_isRoot(false)
+{
+}
+
+void Department::loadFromDepartmentNode(DepartmentNode* treeNode)
+{
+    if (treeNode == nullptr) {
+        qWarning("Tried to set null DepartmentNode!");
+        return;
+    }
+    m_departmentId = treeNode->id();
+    m_label = treeNode->label();
+    m_allLabel = treeNode->allLabel();
+    m_loaded = !treeNode->isLeaf() && treeNode->childCount() > 0;
+    m_isRoot = treeNode->isRoot();
+
+    DepartmentNode* parentNode = treeNode->parent();
+    m_parentDepartmentId = parentNode ? parentNode->id() : "";
+    m_parentLabel = parentNode ? parentNode->label() : "";
+
+    beginResetModel();
+
+    m_subdepartments.clear();
+    Q_FOREACH (DepartmentNode* node, treeNode->childNodes()) {
+        QSharedPointer<SubdepartmentData> subdept(new SubdepartmentData);
+        subdept->id = node->id();
+        subdept->label = node->label();
+        subdept->hasChildren = node->hasSubdepartments();
+        subdept->isActive = false;
+        m_subdepartments.append(subdept);
+    }
+
+    endResetModel();
+
+    Q_EMIT departmentIdChanged();
+    Q_EMIT labelChanged();
+    Q_EMIT allLabelChanged();
+    Q_EMIT parentDepartmentIdChanged();
+    Q_EMIT parentLabelChanged();
+    Q_EMIT loadedChanged();
+    Q_EMIT countChanged();
+    Q_EMIT isRootChanged();
+}
+
+void Department::markSubdepartmentActive(QString const& subdepartmentId)
+{
+    int idx = -1;
+    bool isActiveReset = false;
+    for (int i = 0; i < m_subdepartments.count(); i++) {
+        if (m_subdepartments[i]->id == subdepartmentId) {
+            m_subdepartments[i]->isActive = true;
+            idx = i;
+        } else if (m_subdepartments[i]->isActive) {
+            // only one department can be active
+            m_subdepartments[i]->isActive = false;
+            isActiveReset = true;
+        }
+    }
+
+    if (idx < 0) return;
+
+    QVector<int> roles;
+    roles.append(Roles::RoleIsActive);
+
+    QModelIndex startIndex(index(isActiveReset ? 0 : idx));
+    QModelIndex endIndex(index(isActiveReset ? m_subdepartments.count() - 1 : idx));
+    dataChanged(startIndex, endIndex, roles);
+}
+
+QVariant Department::data(const QModelIndex& index, int role) const
+{
+    SubdepartmentData* data = m_subdepartments[index.row()].data();
+    switch (role) {
+        case RoleDepartmentId: return data->id;
+        case RoleLabel: return data->label;
+        case RoleHasChildren: return data->hasChildren;
+        case RoleIsActive: return data->isActive;
+        default: return QVariant();
+    }
+}
+
+int Department::rowCount(const QModelIndex& parent) const
+{
+    Q_UNUSED(parent);
+    return m_subdepartments.size();
+}
+
+QHash<int, QByteArray> Department::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[RoleDepartmentId] = "departmentId";
+    roles[RoleLabel] = "label";
+    roles[RoleHasChildren] = "hasChildren";
+    roles[RoleIsActive] = "isActive";
+    return roles;
+}
+
+QString Department::departmentId() const
+{
+    return m_departmentId;
+}
+
+QString Department::label() const
+{
+    return m_label;
+}
+
+QString Department::allLabel() const
+{
+    return m_allLabel;
+}
+
+QString Department::parentDepartmentId() const
+{
+    return m_parentDepartmentId;
+}
+
+QString Department::parentLabel() const
+{
+    return m_parentLabel;
+}
+
+bool Department::loaded() const
+{
+    return m_loaded;
+}
+
+bool Department::isRoot() const
+{
+    return m_isRoot;
+}
+
+int Department::count() const
+{
+    return rowCount();
+}
+
+} // namespace scopes_ng

=== added file 'src/Unity/department.h'
--- src/Unity/department.h	1970-01-01 00:00:00 +0000
+++ src/Unity/department.h	2014-06-03 15:51:24 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Michal Hruby <[e-mail]>
+ *
+ * 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/>.
+ */
+
+
+#ifndef NG_DEPARTMENT_H
+#define NG_DEPARTMENT_H
+
+#include <unity/shell/scopes/DepartmentInterface.h>
+
+#include <QString>
+#include <QSharedPointer>
+#include <QPointer>
+#include <QAbstractListModel>
+
+#include <unity/scopes/Result.h>
+#include <unity/scopes/Department.h>
+
+#include "departmentnode.h"
+
+namespace scopes_ng
+{
+
+struct SubdepartmentData
+{
+    QString id;
+    QString label;
+    bool hasChildren;
+    bool isActive;
+};
+
+class Q_DECL_EXPORT Department : public unity::shell::scopes::DepartmentInterface
+{
+    Q_OBJECT
+
+public:
+    explicit Department(QObject* parent = 0);
+    void loadFromDepartmentNode(DepartmentNode* treeNode);
+    void markSubdepartmentActive(QString const& subdepartmentId);
+
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    QString departmentId() const override;
+    QString label() const override;
+    QString allLabel() const override;
+    QString parentDepartmentId() const override;
+    QString parentLabel() const override;
+    bool loaded() const override;
+    bool isRoot() const override;
+    int count() const override;
+
+Q_SIGNALS:
+
+private:
+    QString m_departmentId;
+    QString m_label;
+    QString m_allLabel;
+    QString m_parentDepartmentId;
+    QString m_parentLabel;
+    bool m_loaded;
+    bool m_isRoot;
+
+    QList<QSharedPointer<SubdepartmentData>> m_subdepartments;
+};
+
+} // namespace scopes_ng
+
+Q_DECLARE_METATYPE(scopes_ng::Department*)
+
+#endif // NG_DEPARTMENT_H

=== added file 'src/Unity/departmentnode.cpp'
--- src/Unity/departmentnode.cpp	1970-01-01 00:00:00 +0000
+++ src/Unity/departmentnode.cpp	2014-06-03 15:51:24 +0000
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Michal Hruby <[e-mail]>
+ *
+ * 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/>.
+ */
+
+#include "departmentnode.h"
+
+namespace scopes_ng
+{
+
+using namespace unity;
+
+DepartmentNode::DepartmentNode(DepartmentNode* parent) : m_parent(parent), m_isRoot(false)
+{
+}
+
+DepartmentNode::~DepartmentNode()
+{
+    clearChildren();
+}
+
+void DepartmentNode::initializeForDepartment(scopes::Department::SCPtr const& dep)
+{
+    m_id = QString::fromStdString(dep->id());
+    m_label = QString::fromStdString(dep->label());
+    m_allLabel = QString::fromStdString(dep->alternate_label());
+    m_hasSubdepartments = dep->has_subdepartments();
+
+    clearChildren();
+
+    auto subdeps = dep->subdepartments();
+    for (auto it = subdeps.begin(); it != subdeps.end(); ++it) {
+        DepartmentNode* subdep = new DepartmentNode(this);
+        subdep->initializeForDepartment(*it);
+        this->appendChild(subdep);
+    }
+}
+
+void DepartmentNode::setIsRoot(bool isRoot)
+{
+    m_isRoot = isRoot;
+}
+
+bool DepartmentNode::isRoot() const
+{
+    return m_isRoot;
+}
+
+DepartmentNode* DepartmentNode::findNodeById(QString const& id)
+{
+    if (id == m_id) return this;
+
+    Q_FOREACH(DepartmentNode* child, m_children) {
+        DepartmentNode* node = child->findNodeById(id);
+        if (node) return node;
+    }
+
+    return nullptr;
+}
+
+QString DepartmentNode::id() const
+{
+    return m_id;
+}
+
+QString DepartmentNode::label() const
+{
+    return m_label;
+}
+
+QString DepartmentNode::allLabel() const
+{
+    return m_allLabel;
+}
+
+bool DepartmentNode::hasSubdepartments() const
+{
+    return m_hasSubdepartments;
+}
+
+void DepartmentNode::appendChild(DepartmentNode* child)
+{
+    m_children.append(child);
+}
+
+int DepartmentNode::childCount() const
+{
+    return m_children.count();
+}
+
+QList<DepartmentNode*> DepartmentNode::childNodes() const
+{
+    return m_children;
+}
+
+DepartmentNode* DepartmentNode::parent() const
+{
+    return m_parent;
+}
+
+bool DepartmentNode::isLeaf() const
+{
+    return m_children.count() == 0 && !m_hasSubdepartments;
+}
+
+void DepartmentNode::clearChildren()
+{
+    qDeleteAll(m_children);
+    m_children.clear();
+}
+
+} // namespace scopes_ng

=== added file 'src/Unity/departmentnode.h'
--- src/Unity/departmentnode.h	1970-01-01 00:00:00 +0000
+++ src/Unity/departmentnode.h	2014-06-03 15:51:24 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Michal Hruby <[e-mail]>
+ *
+ * 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/>.
+ */
+
+
+#ifndef NG_DEPARTMENT_NODE_H
+#define NG_DEPARTMENT_NODE_H
+
+#include <QSharedPointer>
+#include <QMultiMap>
+#include <QStringList>
+#include <QPointer>
+
+#include <unity-scopes.h>
+
+namespace scopes_ng
+{
+
+class Q_DECL_EXPORT DepartmentNode
+{
+public:
+    DepartmentNode(DepartmentNode* parent = nullptr);
+    ~DepartmentNode();
+
+    void initializeForDepartment(unity::scopes::Department::SCPtr const& dep);
+    DepartmentNode* findNodeById(QString const& id);
+
+    QString id() const;
+    QString label() const;
+    QString allLabel() const;
+    bool hasSubdepartments() const;
+    bool isRoot() const;
+
+    void setIsRoot(bool isRoot);
+
+    void appendChild(DepartmentNode* child);
+    int childCount() const;
+    bool isLeaf() const;
+    QList<DepartmentNode*> childNodes() const;
+    DepartmentNode* parent() const;
+
+private:
+    void clearChildren();
+
+    DepartmentNode* m_parent;
+    QList<DepartmentNode*> m_children;
+    QString m_id;
+    QString m_label;
+    QString m_allLabel;
+    bool m_hasSubdepartments;
+    bool m_isRoot;
+};
+
+} // namespace scopes_ng
+
+#endif // NG_DEPARTMENT_NODE_H

=== modified file 'src/Unity/plugin.cpp'
--- src/Unity/plugin.cpp	2014-05-19 11:10:04 +0000
+++ src/Unity/plugin.cpp	2014-06-03 15:51:24 +0000
@@ -27,6 +27,7 @@
 #include "scopes.h"
 #include "scope.h"
 #include "categories.h"
+#include "department.h"
 #include "resultsmodel.h"
 #include "previewstack.h"
 #include "previewmodel.h"
@@ -39,6 +40,7 @@
     // new Scopes classes
     qmlRegisterType<scopes_ng::Scopes>(uri, 0, 2, "Scopes");
     qmlRegisterUncreatableType<unity::shell::scopes::ScopeInterface>(uri, 0, 2, "Scope", "Can't create Scope object in QML. Get them from Scopes instance.");
+    qmlRegisterUncreatableType<unity::shell::scopes::DepartmentInterface>(uri, 0, 2, "Department", "Can't create Department object in QML. Get them from Scope instance.");
     qmlRegisterUncreatableType<unity::shell::scopes::CategoriesInterface>(uri, 0, 2, "Categories", "Can't create Categories object in QML. Get them from Scope instance.");
     qmlRegisterUncreatableType<scopes_ng::ResultsModel>(uri, 0, 2, "ResultsModel", "Can't create new ResultsModel in QML. Get them from Categories instance.");
     qmlRegisterUncreatableType<unity::shell::scopes::PreviewModelInterface>(uri, 0, 2, "PreviewModel", "Can't create new PreviewModel in QML. Get them from PreviewStack instance.");

=== modified file 'src/Unity/scope.cpp'
--- src/Unity/scope.cpp	2014-05-22 08:03:59 +0000
+++ src/Unity/scope.cpp	2014-06-03 15:51:24 +0000
@@ -69,6 +69,9 @@
     , m_searchInProgress(false)
     , m_resultsDirty(false)
     , m_delayedClear(false)
+    , m_hasDepartments(false)
+    , m_searchController(new CollectionController)
+    , m_activationController(new CollectionController)
 {
     m_categories = new Categories(this);
 
@@ -86,24 +89,21 @@
 
 Scope::~Scope()
 {
-    if (m_lastSearch) {
-        std::dynamic_pointer_cast<ScopeDataReceiverBase>(m_lastSearch)->invalidate();
-    }
-    if (m_lastActivation) {
-        std::dynamic_pointer_cast<ScopeDataReceiverBase>(m_lastActivation)->invalidate();
-    }
 }
 
 void Scope::processSearchChunk(PushEvent* pushEvent)
 {
     CollectorBase::Status status;
     QList<std::shared_ptr<scopes::CategorisedResult>> results;
+    scopes::Department::SPtr rootDepartment;
 
-    status = pushEvent->collectSearchResults(results);
+    status = pushEvent->collectSearchResults(results, rootDepartment);
     if (status == CollectorBase::Status::CANCELLED) {
         return;
     }
 
+    m_rootDepartment = rootDepartment;
+
     if (m_cachedResults.empty()) {
         m_cachedResults.swap(results);
     } else {
@@ -213,10 +213,12 @@
 
     QString scopeId(QString::fromStdString(query.scope_id()));
     QString searchString(QString::fromStdString(query.query_string()));
+    QString departmentId(QString::fromStdString(query.department_id()));
     // figure out if this scope is already favourited
     Scope* scope = scopes->getScopeById(scopeId);
     if (scope != nullptr) {
-        // TODO: change department, filters?
+        // TODO: change filters?
+        scope->setCurrentDepartmentId(departmentId);
         scope->setSearchQuery(searchString);
         Q_EMIT gotoScope(scopeId);
     } else {
@@ -225,6 +227,7 @@
         if (meta_sptr) {
             scope = new scopes_ng::Scope(this);
             scope->setScopeData(*meta_sptr);
+            scope->setCurrentDepartmentId(departmentId);
             scope->setSearchQuery(searchString);
             m_tempScopes.insert(scope);
             Q_EMIT openScope(scope);
@@ -252,6 +255,85 @@
     }
 
     processResultSet(m_cachedResults); // clears the result list
+
+    // process departments
+    if (m_rootDepartment != m_lastRootDepartment) {
+        // build / append to the tree
+        DepartmentNode* node = nullptr;
+        if (m_departmentTree) {
+            QString departmentId(QString::fromStdString(m_rootDepartment->id()));
+            node = m_departmentTree->findNodeById(departmentId);
+            if (node == nullptr) {
+                node = m_departmentTree.data();
+            }
+            auto depNode = findDepartmentById(m_rootDepartment, m_currentDepartmentId.toStdString());
+            if (depNode && depNode->has_subdepartments()) {
+                node->initializeForDepartment(m_rootDepartment);
+            }
+            // as far as we know, this is the root, re-initializing might have unset the flag
+            m_departmentTree->setIsRoot(true);
+
+            // update corresponding models
+            QString activeDepartment(m_currentDepartmentId);
+            node = m_departmentTree->findNodeById(activeDepartment);
+            DepartmentNode* parentNode = nullptr;
+            if (node != nullptr) {
+                auto it = m_departmentModels.find(activeDepartment);
+                while (it != m_departmentModels.end() && it.key() == activeDepartment) {
+                    it.value()->loadFromDepartmentNode(node);
+                    ++it;
+                }
+                // if this node is a leaf, we need to update models for the parent
+                parentNode = node->isLeaf() ? node->parent() : nullptr;
+            }
+            if (parentNode != nullptr) {
+                auto it = m_departmentModels.find(parentNode->id());
+                while (it != m_departmentModels.end() && it.key() == parentNode->id()) {
+                    it.value()->markSubdepartmentActive(activeDepartment);
+                    ++it;
+                }
+            }
+        } else {
+            m_departmentTree.reset(new DepartmentNode);
+            m_departmentTree->initializeForDepartment(m_rootDepartment);
+            // as far as we know, this is the root, changing our mind later
+            // is better than pretending it isn't
+            m_departmentTree->setIsRoot(true);
+        }
+
+        m_lastRootDepartment = m_rootDepartment;
+    }
+
+    bool containsDepartments = m_rootDepartment.get() != nullptr;
+    // design decision - no departments when doing searches
+    containsDepartments &= m_searchQuery.isEmpty();
+
+    if (containsDepartments != m_hasDepartments) {
+        m_hasDepartments = containsDepartments;
+        Q_EMIT hasDepartmentsChanged();
+    }
+
+    if (!containsDepartments && !m_currentDepartmentId.isEmpty()) {
+        m_currentDepartmentId = "";
+        Q_EMIT currentDepartmentIdChanged();
+    }
+}
+
+scopes::Department::SCPtr Scope::findDepartmentById(scopes::Department::SCPtr const& root, std::string const& id)
+{
+    if (root->id() == id) return root;
+
+    auto sub_deps = root->subdepartments();
+    for (auto it = sub_deps.begin(); it != sub_deps.end(); ++it) {
+        if ((*it)->id() == id) {
+            return *it;
+        } else {
+            auto node = findDepartmentById(*it, id);
+            if (node) return node;
+        }
+    }
+
+    return nullptr;
 }
 
 void Scope::processResultSet(QList<std::shared_ptr<scopes::CategorisedResult>>& result_set)
@@ -289,14 +371,7 @@
 
 void Scope::invalidateLastSearch()
 {
-    if (m_lastSearch) {
-        std::dynamic_pointer_cast<SearchResultReceiver>(m_lastSearch)->invalidate();
-        m_lastSearch.reset();
-    }
-    if (m_lastSearchQuery) {
-        m_lastSearchQuery->cancel();
-        m_lastSearchQuery.reset();
-    }
+    m_searchController->invalidate();
     if (m_aggregatorTimer.isActive()) {
         m_aggregatorTimer.stop();
     }
@@ -338,6 +413,14 @@
     }
 }
 
+void Scope::setCurrentDepartmentId(QString const& id)
+{
+    if (m_currentDepartmentId != id) {
+        m_currentDepartmentId = id;
+        Q_EMIT currentDepartmentIdChanged();
+    }
+}
+
 void Scope::dispatchSearch()
 {
     invalidateLastSearch();
@@ -364,7 +447,7 @@
     if (m_resultsDirty)
     {
         m_resultsDirty = false;
-        resultsDirtyChanged(false);
+        resultsDirtyChanged();
     }
 
     setSearchInProgress(true);
@@ -377,9 +460,11 @@
                 meta["no-internet"] = true;
             }
         }
-        m_lastSearch.reset(new SearchResultReceiver(this));
+        scopes::SearchListenerBase::SPtr listener(new SearchResultReceiver(this));
+        m_searchController->setListener(listener);
         try {
-            m_lastSearchQuery = m_proxy->search(m_searchQuery.toStdString(), meta, m_lastSearch);
+            scopes::QueryCtrlProxy controller = m_proxy->search(m_searchQuery.toStdString(), m_currentDepartmentId.toStdString(), scopes::FilterState(), meta, listener);
+            m_searchController->setController(controller);
         } catch (std::exception& e) {
             qWarning("Caught an error from create_query(): %s", e.what());
         } catch (...) {
@@ -387,7 +472,7 @@
         }
     }
 
-    if (!m_lastSearchQuery) {
+    if (!m_searchController->isValid()) {
         // something went wrong, reset search state
         setSearchInProgress(false);
     }
@@ -470,6 +555,44 @@
 }
 */
 
+unity::shell::scopes::DepartmentInterface* Scope::getDepartment(QString const& departmentId)
+{
+    if (!m_departmentTree) return nullptr;
+
+    DepartmentNode* node = m_departmentTree->findNodeById(departmentId);
+    if (!node) return nullptr;
+
+    Department* departmentModel = new Department;
+    departmentModel->loadFromDepartmentNode(node);
+
+    m_departmentModels.insert(departmentId, departmentModel);
+    m_inverseDepartments.insert(departmentModel, departmentId);
+    QObject::connect(departmentModel, &QObject::destroyed, this, &Scope::departmentModelDestroyed);
+
+    return departmentModel;
+}
+
+void Scope::departmentModelDestroyed(QObject* obj)
+{
+  scopes_ng::Department* department = reinterpret_cast<scopes_ng::Department*>(obj);
+
+  auto it = m_inverseDepartments.find(department);
+  if (it == m_inverseDepartments.end()) return;
+
+  m_departmentModels.remove(it.value(), department);
+  m_inverseDepartments.remove(department);
+}
+
+void Scope::loadDepartment(QString const& departmentId)
+{
+    if (departmentId != m_currentDepartmentId) {
+        m_currentDepartmentId = departmentId;
+        Q_EMIT currentDepartmentIdChanged();
+
+        dispatchSearch();
+    }
+}
+
 QString Scope::searchQuery() const
 {
     return m_searchQuery;
@@ -490,6 +613,16 @@
     return m_isActive;
 }
 
+QString Scope::currentDepartmentId() const
+{
+    return m_currentDepartmentId;
+}
+
+bool Scope::hasDepartments() const
+{
+    return m_hasDepartments;
+}
+
 void Scope::setSearchQuery(const QString& search_query)
 {
     /* Checking for m_searchQuery.isNull() which returns true only when the string
@@ -526,7 +659,7 @@
 void Scope::setActive(const bool active) {
     if (active != m_isActive) {
         m_isActive = active;
-        Q_EMIT isActiveChanged(m_isActive);
+        Q_EMIT isActiveChanged();
 
         if (active && m_resultsDirty) {
             dispatchSearch();
@@ -551,11 +684,14 @@
         activateUri(QString::fromStdString(result->uri()));
     } else {
         try {
+            cancelActivation();
+            scopes::ActivationListenerBase::SPtr listener(new ActivationReceiver(this, result));
+            m_activationController->setListener(listener);
+
             auto proxy = result->target_scope_proxy();
-            // FIXME: don't block
             unity::scopes::ActionMetadata metadata(QLocale::system().name().toStdString(), m_formFactor.toStdString());
-            m_lastActivation.reset(new ActivationReceiver(this, result));
-            proxy->activate(*(result.get()), metadata, m_lastActivation);
+            scopes::QueryCtrlProxy controller = proxy->activate(*(result.get()), metadata, listener);
+            m_activationController->setController(controller);
         } catch (std::exception& e) {
             qWarning("Caught an error from activate(): %s", e.what());
         } catch (...) {
@@ -585,10 +721,7 @@
 
 void Scope::cancelActivation()
 {
-    if (m_lastActivation) {
-        std::dynamic_pointer_cast<ScopeDataReceiverBase>(m_lastActivation)->invalidate();
-        m_lastActivation.reset();
-    }
+    m_activationController->invalidate();
 }
 
 void Scope::invalidateResults()
@@ -600,7 +733,7 @@
         if (!m_resultsDirty)
         {
             m_resultsDirty = true;
-            resultsDirtyChanged(true);
+            resultsDirtyChanged();
         }
     }
 }

=== modified file 'src/Unity/scope.h'
--- src/Unity/scope.h	2014-05-22 08:03:59 +0000
+++ src/Unity/scope.h	2014-06-03 15:51:24 +0000
@@ -26,6 +26,7 @@
 #include <QTimer>
 #include <QMetaType>
 #include <QPointer>
+#include <QMultiMap>
 #include <QSet>
 #include <QGSettings>
 
@@ -36,6 +37,10 @@
 #include <unity/scopes/ScopeMetadata.h>
 #include <unity/shell/scopes/ScopeInterface.h>
 
+#include "collectors.h"
+#include "departmentnode.h"
+#include "department.h"
+
 namespace scopes_ng
 {
 
@@ -43,6 +48,54 @@
 class PushEvent;
 class PreviewStack;
 
+class CollectionController
+{
+public:
+    CollectionController() {}
+    ~CollectionController()
+    {
+        if (m_receiver) {
+            m_receiver->invalidate();
+        }
+        // shouldn't call QueryCtrlProxy->cancel() cause the Runtime might be
+        // in the process of being destroyed
+    }
+
+    bool isValid()
+    {
+        return m_listener && m_controller;
+    }
+
+    void invalidate()
+    {
+        if (m_receiver) {
+            m_receiver->invalidate();
+            m_receiver.reset();
+        }
+        m_listener.reset();
+        if (m_controller) {
+            m_controller->cancel();
+            m_controller.reset();
+        }
+    }
+
+    void setListener(unity::scopes::ListenerBase::SPtr const& listener)
+    {
+        m_listener = listener;
+        m_receiver = std::dynamic_pointer_cast<ScopeDataReceiverBase>(listener);
+    }
+
+    void setController(unity::scopes::QueryCtrlProxy const& controller)
+    {
+        m_controller = controller;
+    }
+
+private:
+    unity::scopes::ListenerBase::SPtr m_listener;
+    std::shared_ptr<ScopeDataReceiverBase> m_receiver;
+    unity::scopes::QueryCtrlProxy m_controller;
+};
+
 class Q_DECL_EXPORT Scope : public unity::shell::scopes::ScopeInterface
 {
     Q_OBJECT
@@ -67,6 +120,8 @@
     QString noResultsHint() const override;
     QString formFactor() const override;
     bool isActive() const override;
+    QString currentDepartmentId() const override;
+    bool hasDepartments() const override;
 
     /* setters */
     void setSearchQuery(const QString& search_query) override;
@@ -78,6 +133,8 @@
     Q_INVOKABLE unity::shell::scopes::PreviewStackInterface* preview(QVariant const& result) override;
     Q_INVOKABLE void cancelActivation() override;
     Q_INVOKABLE void closeScope(unity::shell::scopes::ScopeInterface* scope) override;
+    Q_INVOKABLE unity::shell::scopes::DepartmentInterface* getDepartment(QString const& id) override;
+    Q_INVOKABLE void loadDepartment(QString const& id) override;
 
     void setScopeData(unity::scopes::ScopeMetadata const& data);
     void handleActivation(std::shared_ptr<unity::scopes::ActivationResponse> const&, unity::scopes::Result::SPtr const&);
@@ -89,16 +146,18 @@
     void invalidateResults();
 
 Q_SIGNALS:
-    void resultsDirtyChanged(bool resultsDirty);
+    void resultsDirtyChanged();
 
 private Q_SLOTS:
     void flushUpdates();
     void metadataRefreshed();
     void internetFlagChanged(QString const& key);
+    void departmentModelDestroyed(QObject* obj);
 
 private:
     void startTtlTimer();
     void setSearchInProgress(bool searchInProgress);
+    void setCurrentDepartmentId(QString const& id);
     void processSearchChunk(PushEvent* pushEvent);
     void executeCannedQuery(unity::scopes::CannedQuery const& query, bool allowDelayedActivation);
 
@@ -106,27 +165,35 @@
     void dispatchSearch();
     void invalidateLastSearch();
 
+    static unity::scopes::Department::SCPtr findDepartmentById(unity::scopes::Department::SCPtr const& root, std::string const& id);
+
     QString m_searchQuery;
     QString m_noResultsHint;
     QString m_formFactor;
+    QString m_currentDepartmentId;
     bool m_isActive;
     bool m_searchInProgress;
     bool m_resultsDirty;
     bool m_delayedClear;
+    bool m_hasDepartments;
 
+    std::unique_ptr<CollectionController> m_searchController;
+    std::unique_ptr<CollectionController> m_activationController;
     unity::scopes::ScopeProxy m_proxy;
     unity::scopes::ScopeMetadata::SPtr m_scopeMetadata;
-    unity::scopes::SearchListenerBase::SPtr m_lastSearch;
-    unity::scopes::QueryCtrlProxy m_lastSearchQuery;
-    unity::scopes::ActivationListenerBase::SPtr m_lastActivation;
     std::shared_ptr<unity::scopes::ActivationResponse> m_delayedActivation;
+    unity::scopes::Department::SPtr m_rootDepartment;
+    unity::scopes::Department::SPtr m_lastRootDepartment;
     QGSettings* m_settings;
     Categories* m_categories;
+    QSharedPointer<DepartmentNode> m_departmentTree;
     QTimer m_aggregatorTimer;
     QTimer m_clearTimer;
     QTimer m_invalidateTimer;
     QList<std::shared_ptr<unity::scopes::CategorisedResult>> m_cachedResults;
     QSet<unity::shell::scopes::ScopeInterface*> m_tempScopes;
+    QMultiMap<QString, Department*> m_departmentModels;
+    QMap<Department*, QString> m_inverseDepartments;
 };
 
 } // namespace scopes_ng

=== modified file 'src/Unity/scopes.cpp'
--- src/Unity/scopes.cpp	2014-05-19 09:58:14 +0000
+++ src/Unity/scopes.cpp	2014-06-03 15:51:24 +0000
@@ -162,7 +162,7 @@
     endResetModel();
 
     m_loaded = true;
-    Q_EMIT loadedChanged(m_loaded);
+    Q_EMIT loadedChanged();
     Q_EMIT metadataRefreshed();
 
     m_listThread = nullptr;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-05-22 08:03:59 +0000
+++ tests/CMakeLists.txt	2014-06-03 15:51:24 +0000
@@ -48,6 +48,7 @@
 endmacro(run_tests)
 
 run_tests(
+    departmentstest
     resultstest
     previewtest
     utilstest

=== modified file 'tests/data/CMakeLists.txt'
--- tests/data/CMakeLists.txt	2014-05-02 15:26:40 +0000
+++ tests/data/CMakeLists.txt	2014-06-03 15:51:24 +0000
@@ -1,4 +1,5 @@
 add_subdirectory(mock-scope)
+add_subdirectory(mock-scope-departments)
 add_subdirectory(mock-scope-ttl)
 
 configure_file(Runtime.ini.in Runtime.ini @ONLY)

=== added directory 'tests/data/mock-scope-departments'
=== added file 'tests/data/mock-scope-departments/CMakeLists.txt'
--- tests/data/mock-scope-departments/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/data/mock-scope-departments/CMakeLists.txt	2014-06-03 15:51:24 +0000
@@ -0,0 +1,16 @@
+include(FindPkgConfig)
+pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.4.0)
+
+set(SCOPES_BIN_DIR ${SCOPESLIB_LIBDIR})
+
+include_directories(${SCOPESLIB_INCLUDE_DIRS})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+set(SCOPE_SOURCES
+    mock-scope-departments.cpp
+    )
+
+add_library(mock-scope-departments MODULE ${SCOPE_SOURCES})
+target_link_libraries(mock-scope-departments ${SCOPESLIB_LDFLAGS})
+
+configure_file(mock-scope-departments.ini.in mock-scope-departments.ini)

=== added file 'tests/data/mock-scope-departments/mock-scope-departments.cpp'
--- tests/data/mock-scope-departments/mock-scope-departments.cpp	1970-01-01 00:00:00 +0000
+++ tests/data/mock-scope-departments/mock-scope-departments.cpp	2014-06-03 15:51:24 +0000
@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pete Woods <[e-mail]>
+ */
+
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/ScopeBase.h>
+#include <unity/scopes/SearchReply.h>
+
+#include <iostream>
+#include <thread>
+#include <atomic>
+#include <sstream>
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+using namespace std;
+using namespace unity::scopes;
+
+class MyQuery : public SearchQueryBase
+{
+public:
+    MyQuery(CannedQuery const& query) :
+            query_(query), department_id_(query.department_id())
+    {
+    }
+
+    ~MyQuery()
+    {
+    }
+
+    virtual void cancelled() override
+    {
+    }
+
+    static Department::SPtr create_root_dep(CannedQuery const& query)
+    {
+        Department::SPtr child_dep;
+        Department::SPtr root_dep;
+        root_dep = Department::create("", query, "All departments");
+
+        child_dep = Department::create("books", query, "Books");
+        child_dep->set_has_subdepartments();
+        root_dep->add_subdepartment(child_dep);
+
+        child_dep = Department::create("movies", query, "Movies, TV, Music");
+        child_dep->set_has_subdepartments();
+        root_dep->add_subdepartment(child_dep);
+
+        child_dep = Department::create("electronics", query, "Electronics");
+        child_dep->set_has_subdepartments();
+        root_dep->add_subdepartment(child_dep);
+
+        child_dep = Department::create("home", query, "Home, Garden & DIY");
+        child_dep->set_has_subdepartments();
+        root_dep->add_subdepartment(child_dep);
+
+        child_dep = Department::create("toys", query, "Toys, Children & Baby");
+        child_dep->set_has_subdepartments();
+        root_dep->add_subdepartment(child_dep);
+
+        return root_dep;
+    }
+
+    static Department::SPtr get_department_by_id(Department::SPtr root_dep, std::string const& dep_id)
+    {
+        auto children = root_dep->subdepartments();
+        for (auto it = children.begin(); it != children.end(); ++it)
+        {
+            if ((*it)->id() == dep_id) return const_pointer_cast<Department>(*it);
+        }
+        return Department::SPtr();
+    }
+
+    virtual void run(SearchReplyProxy const& reply) override
+    {
+        Department::SPtr child_dep;
+        Department::SPtr root_dep;
+        Department::SPtr active_dep;
+
+        root_dep = create_root_dep(query_);
+
+        if (department_id_.compare(0, 5, "books") == 0)
+        {
+            active_dep = get_department_by_id(root_dep, "books");
+            child_dep = Department::create("books-kindle", query_, "Kindle Books");
+            active_dep->add_subdepartment(child_dep);
+
+            child_dep = Department::create("books-study", query_, "Books for Study");
+            active_dep->add_subdepartment(child_dep);
+
+            child_dep = Department::create("books-audio", query_, "Audiobooks");
+            active_dep->add_subdepartment(child_dep);
+        }
+
+        if (department_id_.compare(0, 4, "home") == 0)
+        {
+            active_dep = get_department_by_id(root_dep, "home");
+            child_dep = Department::create("home-garden", query_, "Garden & Outdoors");
+            active_dep->add_subdepartment(child_dep);
+
+            child_dep = Department::create("home-furniture", query_, "Homeware & Furniture");
+            active_dep->add_subdepartment(child_dep);
+
+            child_dep = Department::create("home-kitchen", query_, "Kitchen & Dining");
+            active_dep->add_subdepartment(child_dep);
+        }
+
+        if (department_id_.compare(0, 4, "toys") == 0)
+        {
+            active_dep = get_department_by_id(root_dep, "toys");
+            child_dep = Department::create("toys-games", query_, "Toys & Games");
+            active_dep->add_subdepartment(child_dep);
+
+            child_dep = Department::create("toys-baby", query_, "Baby");
+            active_dep->add_subdepartment(child_dep);
+        }
+
+        // provide only partial tree for this leaf
+        if (department_id_ == "toys-games")
+        {
+            root_dep = Department::create("", query_, "All departments");
+            child_dep = Department::create("toys", query_, "Toys, Children & Baby");
+            root_dep->add_subdepartment(child_dep);
+            active_dep = Department::create("toys-games", query_, "Toys & Games");
+            child_dep->add_subdepartment(active_dep);
+        }
+
+        reply->register_departments(root_dep);
+
+        auto cat1 = reply->register_category("cat1", "Category 1", "");
+        CategorisedResult res1(cat1);
+        res1.set_uri("test:uri");
+        res1.set_title("result for: \"" + query_.query_string() + "\"");
+        reply->push(res1);
+    }
+
+protected:
+    CannedQuery query_;
+    string department_id_;
+};
+
+class MyScope : public ScopeBase
+{
+public:
+    MyScope()
+    {
+    }
+
+    virtual int start(string const&, RegistryProxy const&) override
+    {
+        return VERSION;
+    }
+
+    virtual void stop() override {
+    }
+
+    virtual SearchQueryBase::UPtr search(CannedQuery const& q, SearchMetadata const&) override
+    {
+        return SearchQueryBase::UPtr(new MyQuery(q));
+    }
+
+    virtual PreviewQueryBase::UPtr preview(Result const&, ActionMetadata const&) override
+    {
+        return nullptr;
+    }
+};
+
+extern "C"
+{
+
+    EXPORT
+    unity::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_CREATE_FUNCTION()
+    {
+        return new MyScope;
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_DESTROY_FUNCTION(unity::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}

=== added file 'tests/data/mock-scope-departments/mock-scope-departments.ini.in'
--- tests/data/mock-scope-departments/mock-scope-departments.ini.in	1970-01-01 00:00:00 +0000
+++ tests/data/mock-scope-departments/mock-scope-departments.ini.in	2014-06-03 15:51:24 +0000
@@ -0,0 +1,8 @@
+[ScopeConfig]
+DisplayName = mock-departments.DisplayName
+Description = mock-departments.Description
+Art = /mock-departments.Art
+Icon = /mock-departments.Icon
+SearchHint = mock-departments.SearchHint
+HotKey = mock-departments.HotKey
+Author = mock-departments.Author

=== modified file 'tests/data/mock-scope/CMakeLists.txt'
--- tests/data/mock-scope/CMakeLists.txt	2014-05-12 13:13:59 +0000
+++ tests/data/mock-scope/CMakeLists.txt	2014-06-03 15:51:24 +0000
@@ -1,5 +1,5 @@
 include(FindPkgConfig)
-pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.4.0)
+pkg_check_modules(SCOPESLIB REQUIRED libunity-scopes>=0.4.8)
 
 include_directories(${SCOPESLIB_INCLUDE_DIRS})
 

=== modified file 'tests/data/mock-scope/mock-scope.cpp'
--- tests/data/mock-scope/mock-scope.cpp	2014-04-30 17:22:57 +0000
+++ tests/data/mock-scope/mock-scope.cpp	2014-06-03 15:51:24 +0000
@@ -31,8 +31,8 @@
 class MyQuery : public SearchQueryBase
 {
 public:
-    MyQuery(string const& query) :
-        query_(query)
+    MyQuery(string const& query, string const& department_id) :
+        query_(query), department_id_(department_id)
     {
     }
 
@@ -217,6 +217,7 @@
 
 private:
     string query_;
+    string department_id_;
 };
 
 class MyPreview : public PreviewQueryBase
@@ -351,7 +352,7 @@
 
     virtual SearchQueryBase::UPtr search(CannedQuery const& q, SearchMetadata const&) override
     {
-        SearchQueryBase::UPtr query(new MyQuery(q.query_string()));
+        SearchQueryBase::UPtr query(new MyQuery(q.query_string(), q.department_id()));
         cout << "scope-A: created query: \"" << q.query_string() << "\"" << endl;
         return query;
     }

=== added file 'tests/departmentstest.cpp'
--- tests/departmentstest.cpp	1970-01-01 00:00:00 +0000
+++ tests/departmentstest.cpp	2014-06-03 15:51:24 +0000
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2013-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:
+ *  Michal Hruby <[e-mail]>
+ */
+
+#include <QObject>
+#include <QTest>
+#include <QJsonValue>
+#include <QJsonObject>
+#include <QThread>
+#include <QScopedPointer>
+#include <QSignalSpy>
+#include <QVariantList>
+#include <QDBusConnection>
+
+#include <scopes.h>
+#include <scope.h>
+#include <categories.h>
+#include <resultsmodel.h>
+#include <previewmodel.h>
+#include <previewstack.h>
+#include <previewwidgetmodel.h>
+#include <department.h>
+
+#include "registry-spawner.h"
+#include "test-utils.h"
+
+using namespace scopes_ng;
+using namespace unity::shell::scopes;
+
+class DepartmentsTest : public QObject
+{
+    Q_OBJECT
+private:
+    QScopedPointer<Scopes> m_scopes;
+    Scope* m_scope;
+    QScopedPointer<RegistrySpawner> m_registry;
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        m_registry.reset(new RegistrySpawner);
+    }
+
+    void cleanupTestCase()
+    {
+        m_registry.reset();
+    }
+
+    void init()
+    {
+        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);
+        // should have one scope now
+        QVERIFY(m_scopes->rowCount() > 1);
+
+        // get scope proxy
+        m_scope = qobject_cast<scopes_ng::Scope*>(m_scopes->getScope(QString("mock-scope-departments")));
+        QVERIFY(m_scope != nullptr);
+    }
+
+    void cleanup()
+    {
+        m_scopes.reset();
+        m_scope = nullptr;
+    }
+
+    void testNoDepartments()
+    {
+        performSearch(m_scope, QString("foo"));
+
+        QCOMPARE(m_scope->hasDepartments(), false);
+    }
+
+    void testRootDepartment()
+    {
+        performSearch(m_scope, QString(""));
+
+        QCOMPARE(m_scope->hasDepartments(), true);
+        QCOMPARE(m_scope->currentDepartmentId(), QString(""));
+        QScopedPointer<DepartmentInterface> departmentModel(m_scope->getDepartment(m_scope->currentDepartmentId()));
+        QVERIFY(departmentModel != nullptr);
+
+        QVERIFY(departmentModel->departmentId().isEmpty());
+        QCOMPARE(departmentModel->label(), QString("All departments"));
+        QCOMPARE(departmentModel->allLabel(), QString(""));
+        QCOMPARE(departmentModel->parentDepartmentId(), QString());
+        QCOMPARE(departmentModel->parentLabel(), QString());
+        QCOMPARE(departmentModel->loaded(), true);
+        QCOMPARE(departmentModel->isRoot(), true);
+
+        QCOMPARE(departmentModel->rowCount(), 5);
+        QModelIndex idx;
+
+        idx = departmentModel->index(0);
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleDepartmentId), QVariant(QString("books")));
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleLabel), QVariant(QString("Books")));
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleHasChildren), QVariant(true));
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleIsActive), QVariant(false));
+
+        idx = departmentModel->index(4);
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleDepartmentId), QVariant(QString("toys")));
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleLabel), QVariant(QString("Toys, Children & Baby")));
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleHasChildren), QVariant(true));
+        QCOMPARE(departmentModel->data(idx, Department::Roles::RoleIsActive), QVariant(false));
+    }
+
+    void testChildDepartmentModel()
+    {
+        performSearch(m_scope, QString(""));
+
+        QCOMPARE(m_scope->currentDepartmentId(), QString(""));
+        QScopedPointer<DepartmentInterface> departmentModel(m_scope->getDepartment(QString("toys")));
+        QVERIFY(departmentModel != nullptr);
+
+        QSignalSpy spy(departmentModel.data(), SIGNAL(loadedChanged()));
+
+        QCOMPARE(departmentModel->departmentId(), QString("toys"));
+        QCOMPARE(departmentModel->label(), QString("Toys, Children & Baby"));
+        QCOMPARE(departmentModel->allLabel(), QString(""));
+        QCOMPARE(departmentModel->parentDepartmentId(), QString(""));
+        QCOMPARE(departmentModel->parentLabel(), QString("All departments"));
+        QCOMPARE(departmentModel->loaded(), false);
+        QCOMPARE(departmentModel->isRoot(), false);
+
+        QCOMPARE(departmentModel->rowCount(), 0);
+
+        m_scope->loadDepartment(QString("toys"));
+        QVERIFY(spy.wait());
+
+        QCOMPARE(departmentModel->rowCount(), 2);
+        QCOMPARE(departmentModel->loaded(), true);
+        QCOMPARE(departmentModel->isRoot(), false);
+    }
+
+    void testLeafActivationUpdatesModel()
+    {
+        performSearch(m_scope, QString(""));
+
+        QCOMPARE(m_scope->currentDepartmentId(), QString(""));
+        QSignalSpy spy(m_scope, SIGNAL(searchInProgressChanged()));
+        m_scope->loadDepartment(QString("books"));
+        QVERIFY(spy.wait());
+        QCOMPARE(m_scope->searchInProgress(), false);
+        QScopedPointer<DepartmentInterface> departmentModel(m_scope->getDepartment(QString("books")));
+        QCOMPARE(departmentModel->isRoot(), false);
+
+        // this is a leaf department, so activating it should update the parent model
+        m_scope->loadDepartment(QString("books-audio"));
+        QVERIFY(spy.wait());
+        QCOMPARE(m_scope->searchInProgress(), false);
+        QCOMPARE(departmentModel->isRoot(), false);
+
+        bool foundAudiobooks = false;
+        for (int i = 0; i < departmentModel->rowCount(); i++) {
+            QModelIndex idx(departmentModel->index(i));
+            QVariant data = departmentModel->data(idx, Department::Roles::RoleDepartmentId);
+            if (data.toString() == QString("books-audio")) {
+                QCOMPARE(departmentModel->data(idx, Department::Roles::RoleIsActive).toBool(), true);
+                foundAudiobooks = true;
+            }
+        }
+        QCOMPARE(foundAudiobooks, true);
+    }
+
+    void testGoingBack()
+    {
+        performSearch(m_scope, QString(""));
+
+        QCOMPARE(m_scope->currentDepartmentId(), QString(""));
+        QSignalSpy spy(m_scope, SIGNAL(searchInProgressChanged()));
+        m_scope->loadDepartment(QString("books"));
+        QVERIFY(spy.wait());
+        QCOMPARE(m_scope->searchInProgress(), false);
+        QScopedPointer<DepartmentInterface> departmentModel(m_scope->getDepartment(QString("books")));
+        QCOMPARE(departmentModel->isRoot(), false);
+
+        // get the root again without actually loading the department
+        departmentModel.reset(m_scope->getDepartment(departmentModel->parentDepartmentId()));
+        QCOMPARE(departmentModel->isRoot(), true);
+        QEXPECT_FAIL("", "We have the department in cache, to it kind of is loaded", Continue);
+        QCOMPARE(departmentModel->loaded(), false);
+    }
+
+    void testIncompleteTreeOnLeaf()
+    {
+        QScopedPointer<DepartmentInterface> departmentModel;
+        performSearch(m_scope, QString(""));
+
+        QCOMPARE(m_scope->currentDepartmentId(), QString(""));
+        QCOMPARE(m_scope->hasDepartments(), true);
+
+        QSignalSpy spy(m_scope, SIGNAL(searchInProgressChanged()));
+        m_scope->loadDepartment(QString("toys"));
+        QVERIFY(spy.wait());
+        QCOMPARE(m_scope->searchInProgress(), false);
+
+        departmentModel.reset(m_scope->getDepartment(QString("toys")));
+        QCOMPARE(departmentModel->isRoot(), false);
+        QCOMPARE(departmentModel->rowCount(), 2);
+
+        m_scope->loadDepartment(QString("toys-games"));
+        QVERIFY(spy.wait());
+        QCOMPARE(m_scope->searchInProgress(), false);
+
+        // after getting the parent department model, it should still have
+        // all the leaves, even though the leaf served just itself
+        departmentModel.reset(m_scope->getDepartment(QString("toys")));
+        QCOMPARE(departmentModel->isRoot(), false);
+        QCOMPARE(departmentModel->rowCount(), 2);
+    }
+
+};
+
+QTEST_GUILESS_MAIN(DepartmentsTest)
+#include <departmentstest.moc>

=== modified file 'tests/previewtest.cpp'
--- tests/previewtest.cpp	2014-05-22 08:03:59 +0000
+++ tests/previewtest.cpp	2014-06-03 15:51:24 +0000
@@ -62,18 +62,19 @@
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
         QCOMPARE(m_scopes->loaded(), false);
-        QSignalSpy spy(m_scopes.data(), SIGNAL(loadedChanged(bool)));
+        QSignalSpy spy(m_scopes.data(), SIGNAL(loadedChanged()));
         // wait till the registry spawns
         QVERIFY(spy.wait());
         QCOMPARE(m_scopes->loaded(), true);
         // should have one scope now
-        QCOMPARE(m_scopes->rowCount(), 2);
+        QCOMPARE(m_scopes->rowCount(), 3);
 
         QVariant scope_var = m_scopes->data(m_scopes->index(0), Scopes::Roles::RoleScope);
         QVERIFY(scope_var.canConvert<Scope*>());
 
         // get scope proxy
         m_scope = scope_var.value<Scope*>();
+        QCOMPARE(m_scope->id(), QString("mock-scope"));
     }
 
     void cleanup()

=== modified file 'tests/resultstest.cpp'
--- tests/resultstest.cpp	2014-05-22 08:03:59 +0000
+++ tests/resultstest.cpp	2014-06-03 15:51:24 +0000
@@ -107,22 +107,20 @@
         // no scopes on startup
         QCOMPARE(m_scopes->rowCount(), 0);
         QCOMPARE(m_scopes->loaded(), false);
-        QSignalSpy spy(m_scopes.data(), SIGNAL(loadedChanged(bool)));
+        QSignalSpy spy(m_scopes.data(), SIGNAL(loadedChanged()));
         // wait till the registry spawns
         QVERIFY(spy.wait());
         QCOMPARE(m_scopes->loaded(), true);
         // should have one scope now
-        QCOMPARE(m_scopes->rowCount(), 2);
+        QCOMPARE(m_scopes->rowCount(), 3);
 
         // get scope proxy
-        QVariant scope_var = m_scopes->data(m_scopes->index(0), Scopes::Roles::RoleScope);
-        QVERIFY(scope_var.canConvert<Scope*>());
-        m_scope = scope_var.value<Scope*>();
+        m_scope = qobject_cast<scopes_ng::Scope*>(m_scopes->getScope(QString("mock-scope")));
+        QVERIFY(m_scope != nullptr);
 
         // get scope proxy for TTL scope
-        scope_var = m_scopes->data(m_scopes->index(1), Scopes::Roles::RoleScope);
-        QVERIFY(scope_var.canConvert<Scope*>());
-        m_scope_ttl = scope_var.value<Scope*>();
+        m_scope_ttl = qobject_cast<scopes_ng::Scope*>(m_scopes->getScope(QString("mock-scope-ttl")));
+        QVERIFY(m_scope != nullptr);
     }
 
     void cleanup()
@@ -307,7 +305,7 @@
 
     void testInactiveTtlScope()
     {
-        QSignalSpy dirtySpy(m_scope_ttl, SIGNAL(resultsDirtyChanged(bool)));
+        QSignalSpy dirtySpy(m_scope_ttl, SIGNAL(resultsDirtyChanged()));
 
         m_scope_ttl->setActive(false);
         performSearch(m_scope_ttl, "banana");
@@ -318,10 +316,6 @@
         }
 
         // Model should go dirty
-        QList<QVariantList> expected;
-        expected << (QVariantList() << true);
-        QVERIFY(dirtySpy == expected);
-
         QVERIFY(m_scope_ttl->resultsDirty());
     }
 
@@ -623,7 +617,7 @@
 
         QSignalSpy spy(m_scopes.data(), SIGNAL(metadataRefreshed()));
         QSignalSpy spy2(m_scope, SIGNAL(gotoScope(QString)));
-        QSignalSpy spy3(m_scope, SIGNAL(openScope(scopes_ng::Scope*)));
+        QSignalSpy spy3(m_scope, SIGNAL(openScope(unity::shell::scopes::ScopeInterface*)));
         // this tries to activate non-existing scope
         m_scope->activate(QVariant::fromValue(result));
         QVERIFY(spy.wait());