Merge lp:~unity-team/unity/unity-lens.to.scope into lp:unity

[Nick Dedekind]

.

[lp:~unity-team/unity/unity-lens.to.scope]

3010. By Nick Dedekind on 2013-01-21

more cleanup

3011. By Nick Dedekind on 2013-01-21

Reverted ModelIterator to ResultIterator

3012. By Nick Dedekind on 2013-01-21

Reverted more unnecessary changes.

[Michal Hruby (mhr3)]

334 +const std::string ALWAYS_SEARCH_SETTINGS_KEY = "always-search";

This is only relevant for the home scope implementation, unity doesn't need to know. All it needs are the scopes key, which it displays icons in LensBar for.

3010 + <default>[ 'home.scope' , 'applications.scope' ]</default>

We'll need to change the default before merging (to include files, music etc). Order is already specified by design in bug 1056196.

[lp:~unity-team/unity/unity-lens.to.scope]

3013. By Nick Dedekind on 2013-01-21

removed filter_update for changes in libunity

3014. By Nick Dedekind on 2013-01-21

Merged with trunk

3015. By Nick Dedekind on 2013-01-21

Fixed 64bit size_t->unsigned int conversion.

3016. By Nick Dedekind on 2013-01-21

Connected up client filter updates to scope backend.

3017. By Nick Dedekind on 2013-01-21

more 64bit fixes

[Marco Trevisan (Treviño) (3v1n0)]

320 +// wrapper for raw const gchar*. non-deleteable.
321 +class StringRef : boost::noncopyable

I also wanted to do this before, but I always been suggested to instead just add a function into the glib namespace that takes a gchar* returning a std::string with just a null-check on it...

[Michal Hruby (mhr3)]

+++ UnityCore/MusicPreview.cpp 2013-01-21 16:58:59 +0000
@@ -70,7 +71,12 @@

+ else
+ g_assert(false);

Nasty, LOG_ERROR() pls.

@@ -81,7 +87,12 @@

+ else
+ g_assert(false);

Same as above

+++ UnityCore/Preview.cpp 2013-01-21 16:58:59 +0000
@@ -229,7 +229,12 @@

+ else
+ g_assert(false);

Same

+++ UnityCore/ScopeData.cpp 2013-01-21 22:19:45 +0000
+ if (error)
+ {
+ data->id = scope_id;
+ LOG_DEBUG(logger) << "Error fetching metadata for scope: " << scope_id << " : " << error.Message();
+ }

This is pretty serious error, perhaps propagate it to the caller? If a .scope file can't be found proxy can't be created and therefore it doesn't even make sense to try to display an icon for the .scope file. Bottom line - invalid scope ids should be completely ignored (and LOG_WARNed)

+void ScopeProxy::Impl::DestroyProxy()
+{
+ scope_proxy_.Release();
+ if (cancel_scope_)
+ {
+ g_cancellable_cancel(cancel_scope_);
+ cancel_scope_ = g_cancellable_new();
+ }
+ cancel_scope_ = g_cancellable_new();

Why the double creation?

+void ScopeProxy::Impl::OnScopeChannelsInvalidated(UnityProtocolScopeProxy* proxy)
+{
+ LOG_WARNING(logger) << "Channels for scope '" << scope_data_->dbus_path() << "' have been invalidated. Attempting proxy re-creation.";
+ DestroyProxy();
+ CreateProxy();
+}

Shouldn't be needed, UnityProtocolScopeProxy is clever, it will try to reconnect to the scope automatically, are we missing notifications when this happens?

+GHashTable* hashtable_from_hintsmap(glib::HintsMap const& hints, GHashTable* hash_table)
+{
+ if (!hash_table)
+ return nullptr;
+
+ for (glib::HintsMap::const_iterator it = hints.begin(); it != hints.end(); ++it)
+ {
+ gchar* key = g_strdup(it->first.c_str());
+ GVariant* ptr = g_variant_ref(it->second);
+
+ g_hash_table_insert(hash_table, key, ptr);
+ }
+ return hash_table;
+}

Too easy to get wrong, the passed hashtable needs to have key_destroy_func set to g_free and value_destroy_func to g_variant_unref. Perhaps just return a hash table without making it an in param?

+++ UnityCore/ScopeProxy.cpp 2013-01-21 20:39:28 +0000
+ GHashTable* hints_table = glib::hashtable_from_hintsmap(hints, g_hash_table_new(g_direct_hash, g_direct_equal));

The poor hashtable is leaking, the proxy doesn't steal it.

[lp:~unity-team/unity/unity-lens.to.scope]

3018. By Nick Dedekind on 2013-01-22

Added cancellable to scope calls

3019. By Nick Dedekind on 2013-01-22

Removed StringRef. removed always-search

3020. By Nick Dedekind on 2013-01-22

reverted changes to function declarations.

3021. By Nick Dedekind on 2013-01-22

Review fixes. Scopes now initialized with ScopeData structure.

3022. By Nick Dedekind on 2013-01-23

Fixed connections in scope.

3023. By Nick Dedekind on 2013-01-23

Merge with trunk.

3024. By Nick Dedekind on 2013-01-23

Fixed filter variant serialization.

3025. By Nick Dedekind on 2013-01-23

Added category order change connections.

3026. By Nick Dedekind on 2013-01-23

removed visibility fetching from proxy

3027. By Nick Dedekind on 2013-01-23

renaming .lens files to .scope

3028. By Nick Dedekind on 2013-01-24

Implemented re-opening of channel on reconnection.

3029. By Nick Dedekind on 2013-01-25

Fixed connected property validation.

3030. By Michal Hruby on 2013-01-25

Fix reconnection

3031. By Nick Dedekind on 2013-02-13

Merged with trunk

3032. By Nick Dedekind on 2013-02-21

merge with trunk

Unmerged revisions

3032. By Nick Dedekind on 2013-02-21

merge with trunk

3031. By Nick Dedekind on 2013-02-13

Merged with trunk

3030. By Michal Hruby on 2013-01-25

Fix reconnection

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2012-12-19 20:53:12 +0000
+++ UnityCore/CMakeLists.txt	2013-02-21 10:37:29 +0000
@@ -21,7 +21,6 @@
      CheckOptionFilter.h
      DBusIndicators.h
      DesktopUtilities.h
-     FilesystemLenses.h
      Filter.h
      Filters.h
      GenericPreview.h
@@ -31,13 +30,12 @@
      GLibSource.h
      GLibWrapper.h
      GLibWrapper-inl.h
+     GSettingsScopes.h
      Hud.h
-     HomeLens.h
      IndicatorEntry.h
      Indicator.h
      Indicators.h
-     Lens.h
-     Lenses.h
+     MiscUtils.h
      MoviePreview.h
      MultiRangeFilter.h
      MusicPreview.h
@@ -51,6 +49,11 @@
      Result.h
      ResultIterator.h
      Results.h
+     Scope.h
+     ScopeData.h
+     Scopes.h
+     ScopeProxy.h
+     ScopeProxyInterface.h
      SeriesPreview.h
      SocialPreview.h
      Track.h
@@ -66,7 +69,6 @@
      CheckOptionFilter.cpp
      DBusIndicators.cpp
      DesktopUtilities.cpp
-     FilesystemLenses.cpp
      Filter.cpp
      Filters.cpp
      GenericPreview.cpp
@@ -74,12 +76,11 @@
      GLibSignal.cpp
      GLibSource.cpp
      GLibWrapper.cpp
+     GSettingsScopes.cpp
      Hud.cpp
-     HomeLens.cpp
      Indicator.cpp
      IndicatorEntry.cpp
      Indicators.cpp
-     Lens.cpp
      MoviePreview.cpp
      MultiRangeFilter.cpp
      MusicPreview.cpp
@@ -90,6 +91,10 @@
      Result.cpp
      ResultIterator.cpp
      Results.cpp
+     Scope.cpp
+     ScopeData.cpp
+     Scopes.cpp
+     ScopeProxy.cpp
      SeriesPreview.cpp
      SocialPreview.cpp
      Track.cpp
 
=== modified file 'UnityCore/Categories.cpp'
--- UnityCore/Categories.cpp	2012-03-14 06:24:18 +0000
+++ UnityCore/Categories.cpp	2013-02-21 10:37:29 +0000
@@ -25,6 +25,7 @@
 {
 
 Categories::Categories()
+ : Model<Category>::Model(REMOTE)
 {
   row_added.connect(sigc::mem_fun(this, &Categories::OnRowAdded));
   row_changed.connect(sigc::mem_fun(this, &Categories::OnRowChanged));
 
=== modified file 'UnityCore/Category.cpp'
--- UnityCore/Category.cpp	2012-11-29 13:28:27 +0000
+++ UnityCore/Category.cpp	2013-02-21 10:37:29 +0000
@@ -26,6 +26,15 @@
 namespace dash
 {
 
+enum CategoryColumn
+{
+  ID = 0,
+  DISPLAY_NAME,
+  ICON_HINT,
+  RENDERER_NAME,
+  HINTS
+};
+
 Category::Category(DeeModel* model,
                    DeeModelIter* iter,
                    DeeModelTag* renderer_name_tag)
@@ -49,10 +58,11 @@
 
 void Category::SetupGetters()
 {
-  name.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), 0));
-  icon_hint.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), 1));
+  id.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), CategoryColumn::ID));
+  name.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), CategoryColumn::DISPLAY_NAME));
+  icon_hint.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), CategoryColumn::ICON_HINT));
+  renderer_name.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), CategoryColumn::RENDERER_NAME));
   index.SetGetterFunction(sigc::mem_fun(this, &Category::get_index));
-  renderer_name.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), 2));
 }
 
 std::size_t Category::get_index() const
 
=== modified file 'UnityCore/Category.h'
--- UnityCore/Category.h	2011-07-31 08:39:48 +0000
+++ UnityCore/Category.h	2013-02-21 10:37:29 +0000
@@ -38,10 +38,11 @@
   Category(Category const& other);
   Category& operator=(Category const& other);
   
+  nux::ROProperty<std::string> id;
   nux::ROProperty<std::string> name;
   nux::ROProperty<std::string> icon_hint;
+  nux::ROProperty<std::string> renderer_name;
   nux::ROProperty<std::size_t> index;
-  nux::ROProperty<std::string> renderer_name;
 
 private:
   void SetupGetters();
 
=== modified file 'UnityCore/FilesystemLenses.cpp'
--- UnityCore/FilesystemLenses.cpp	2012-10-29 09:34:54 +0000
+++ UnityCore/FilesystemLenses.cpp	2013-02-21 10:37:29 +0000
@@ -81,12 +81,11 @@
  * /usr/share/unity/lenses
  *                        /applications
  *                                     /applications.lens
- *                                     /applications.scope
- *                                     /chromium-webapps.scope
+ *                                     /chromium-webapps.lens
  *                        /files
  *                              /files.lens
- *                              /zeitgiest.scope
- *                              /ubuntuone.scope
+ *                              /zeitgiest.lens
+ *                              /ubuntuone.lens
  *
  * Etc, etc. We therefore need to enumerate these directories and find our
  * .lens files in them.
@@ -401,7 +400,7 @@
   }
 
   for (Lens::Ptr& lens: lenses_)
-    owner_->lens_added.emit(lens);
+    owner_->lenses_added.emit(lens);
 
   owner_->lenses_loaded.emit();
 }
 
=== modified file 'UnityCore/Filter.cpp'
--- UnityCore/Filter.cpp	2012-10-29 09:34:54 +0000
+++ UnityCore/Filter.cpp	2013-02-21 10:37:29 +0000
@@ -25,6 +25,7 @@
 #include "MultiRangeFilter.h"
 #include "RadioOptionFilter.h"
 #include "RatingsFilter.h"
+#include "GLibWrapper.h"
 
 namespace unity
 {
@@ -154,6 +155,26 @@
   g_variant_unref(row_value);
 }
 
+glib::Variant Filter::VariantValue() const
+{
+  if (!IsValid())
+    return glib::Variant();
+
+  GVariantBuilder hints;
+  g_variant_builder_init  (&hints, G_VARIANT_TYPE("(ssssa{sv}bbb)"));
+
+  g_variant_builder_add(&hints, "s", id().c_str(), NULL);
+  g_variant_builder_add(&hints, "s", name().c_str(), NULL);
+  g_variant_builder_add(&hints, "s", icon_hint().c_str(), NULL);
+  g_variant_builder_add(&hints, "s", renderer_name().c_str(), NULL);
+  g_variant_builder_add(&hints, "@a{sv}", dee_model_get_value(model_, iter_, FilterColumn::RENDERER_STATE), NULL);
+  g_variant_builder_add(&hints, "b", visible(), NULL);
+  g_variant_builder_add(&hints, "b", collapsed(), NULL);
+  g_variant_builder_add(&hints, "b", filtering(), NULL);
+
+  return glib::Variant(g_variant_builder_end(&hints));
+}
+
 std::string Filter::get_id() const
 {
   if (IsValid())
 
=== modified file 'UnityCore/Filter.h'
--- UnityCore/Filter.h	2012-07-16 11:03:32 +0000
+++ UnityCore/Filter.h	2013-02-21 10:37:29 +0000
@@ -77,6 +77,8 @@
   virtual void Clear() = 0;
   bool IsValid() const;
 
+  glib::Variant VariantValue() const;
+
   nux::ROProperty<std::string> id;
   nux::ROProperty<std::string> name;
   nux::ROProperty<std::string> icon_hint;
 
=== modified file 'UnityCore/Filters.cpp'
--- UnityCore/Filters.cpp	2012-03-14 06:24:18 +0000
+++ UnityCore/Filters.cpp	2013-02-21 10:37:29 +0000
@@ -50,6 +50,7 @@
 
 
 Filters::Filters()
+: Model<FilterAdaptor>::Model(ModelType::REMOTE)
 {
   row_added.connect(sigc::mem_fun(this, &Filters::OnRowAdded));
   row_changed.connect(sigc::mem_fun(this, &Filters::OnRowChanged));
@@ -57,7 +58,7 @@
 }
 
 Filters::Filters(ModelType model_type)
- : Model<FilterAdaptor>::Model(model_type)
+: Model<FilterAdaptor>::Model(model_type)
 {
   row_added.connect(sigc::mem_fun(this, &Filters::OnRowAdded));
   row_changed.connect(sigc::mem_fun(this, &Filters::OnRowChanged));
@@ -70,6 +71,10 @@
 Filter::Ptr Filters::FilterAtIndex(std::size_t index)
 {
   FilterAdaptor adaptor = RowAtIndex(index);
+  if (filter_map_.find(adaptor.iter()) == filter_map_.end())
+  {
+    OnRowAdded(adaptor);
+  }
   return filter_map_[adaptor.iter()];
 }
 
 
=== modified file 'UnityCore/GLibWrapper.cpp'
--- UnityCore/GLibWrapper.cpp	2012-03-14 06:24:18 +0000
+++ UnityCore/GLibWrapper.cpp	2013-02-21 10:37:29 +0000
@@ -69,7 +69,6 @@
   return o;
 }
 
-
 String::String()
   : string_(0)
 {}
@@ -116,10 +115,7 @@
 
 std::string String::Str() const
 {
-  if (string_)
-    return std::string(string_);
-  else
-    return std::string("");
+  return glib::gchar_to_string(string_);
 }
 
 std::ostream& operator<<(std::ostream& o, String const& s)
 
=== modified file 'UnityCore/GLibWrapper.h'
--- UnityCore/GLibWrapper.h	2012-07-04 20:16:06 +0000
+++ UnityCore/GLibWrapper.h	2013-02-21 10:37:29 +0000
@@ -105,6 +105,7 @@
   GError* error_;
 };
 
+// wrapper for raw gcha*. auto-deleted.
 class String : boost::noncopyable
 {
 public:
@@ -125,6 +126,14 @@
   gchar* string_;
 };
 
+inline std::string gchar_to_string(const char* str)
+{
+  if (!str)
+    return std::string("");
+  else
+    return std::string(str);
+}
+
 std::ostream& operator<<(std::ostream& o, Error const& e);
 std::ostream& operator<<(std::ostream& o, String const& s);
 
 
=== added file 'UnityCore/GSettingsScopes.cpp'
--- UnityCore/GSettingsScopes.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/GSettingsScopes.cpp	2013-02-21 10:37:29 +0000
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+
+#include "GSettingsScopes.h"
+
+#include "Scope.h"
+
+namespace unity
+{
+namespace dash
+{
+DECLARE_LOGGER(logger, "unity.dash.gsettingsscopereader");
+
+namespace
+{
+const std::string SETTINGS_NAME = "com.canonical.Unity.Dash";
+const std::string SCOPE_SETTINGS_KEY = "scopes";
+}
+
+class GSettingsScopesReader::Impl
+{
+public:
+  Impl(GSettingsScopesReader* owner);
+  ~Impl() {}
+
+  void LoadScopes();
+
+  GSettingsScopesReader* owner_;
+  bool loaded_;
+
+  glib::Object<GSettings> settings_;
+  glib::Signal<void, GSettings*, gchar*> scopes_changed;
+
+  std::vector<std::string> get_string_vector(std::string const& setting)
+  {
+    std::vector<std::string> vector;
+
+    std::unique_ptr<gchar*[], void(*)(gchar**)> strings(g_settings_get_strv(settings_, setting.c_str()), g_strfreev);
+
+    for (int i = 0; strings[i]; ++i)
+    { 
+      std::string value = strings[i];
+
+      if (!value.empty())
+        vector.push_back(value);
+    }
+    return vector;
+  }
+
+  ScopeDataList scopes_order_;
+};
+
+
+GSettingsScopesReader::Impl::Impl(GSettingsScopesReader* owner)
+: owner_(owner)
+, loaded_(false)
+, settings_(g_settings_new(SETTINGS_NAME.c_str()))
+{
+  auto change_func = [&] (GSettings*, gchar*)
+  {
+    if (loaded_)
+    {
+      LoadScopes();
+      owner_->scopes_changed.emit(scopes_order_);
+    }    
+  };
+
+  scopes_changed.Connect(settings_, "changed::"+SCOPE_SETTINGS_KEY, change_func);
+}
+
+
+void GSettingsScopesReader::Impl::LoadScopes()
+{
+  std::vector<std::string> tmp_scope_ids = get_string_vector(SCOPE_SETTINGS_KEY);
+
+  ScopeDataList old_scopes_order = scopes_order_;
+  scopes_order_.clear();
+
+  // insert new
+  for (std::string const& scope_id : tmp_scope_ids)
+  {
+    auto match_scope_data_to_id = [scope_id](ScopeData::Ptr const& scope_data) { return scope_data->id() == scope_id; };
+
+    ScopeData::Ptr scope;
+    auto scope_position = std::find_if(old_scopes_order.begin(), old_scopes_order.end(), match_scope_data_to_id);
+    if (scope_position == old_scopes_order.end())
+    {
+      glib::Error error;
+      scope = ScopeData::ReadProtocolDataForId(scope_id, error);
+      if (error)
+      {
+        LOG_WARN(logger) << "Error fetching protocol metadata for scope: " << scope_id << " : " << error.Message();
+        continue;
+      }
+    }
+    else
+    {
+      scope = *scope_position;
+    }
+
+    if (scope)
+    {
+      scopes_order_.push_back(scope);
+    }
+  }
+  loaded_ = true;
+}
+
+
+GSettingsScopesReader::GSettingsScopesReader()
+: pimpl(new Impl(this))
+{
+}
+
+void GSettingsScopesReader::LoadScopes()
+{
+  pimpl->LoadScopes();  
+}
+
+ScopeDataList const& GSettingsScopesReader::GetScopesData() const
+{
+  if (!pimpl->loaded_)
+    pimpl->LoadScopes();
+  return pimpl->scopes_order_;  
+}
+
+ScopeData::Ptr GSettingsScopesReader::GetScopeDataById(std::string const& scope_id) const
+{
+  if (!pimpl->loaded_)
+    pimpl->LoadScopes();
+
+  auto match_scope_data_to_id = [scope_id](ScopeData::Ptr const& scope_data) { return scope_data->id() == scope_id; };
+  auto scope_position = std::find_if(pimpl->scopes_order_.begin(), pimpl->scopes_order_.end(), match_scope_data_to_id);
+
+  if (scope_position == pimpl->scopes_order_.end())
+    return ScopeData::Ptr();
+
+  return *scope_position;
+}
+
+GSettingsScopesReader::Ptr GSettingsScopesReader::GetDefault()
+{
+  static GSettingsScopesReader::Ptr main_reader(new GSettingsScopesReader());
+
+  return main_reader;
+}
+
+GSettingsScopes::GSettingsScopes()
+: Scopes(GSettingsScopesReader::GetDefault())
+{
+
+}
+
+} // namespace dash
+} // namespace unity
 \ No newline at end of file
 
=== added file 'UnityCore/GSettingsScopes.h'
--- UnityCore/GSettingsScopes.h	1970-01-01 00:00:00 +0000
+++ UnityCore/GSettingsScopes.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef UNITY_GSETTINGS_SCOPES_H
+#define UNITY_GSETTINGS_SCOPES_H
+
+#include "Scopes.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class GSettingsScopesReader : public ScopesReader
+{
+public:
+  typedef std::shared_ptr<GSettingsScopesReader> Ptr;
+  GSettingsScopesReader();
+
+  virtual void LoadScopes();
+  virtual ScopeDataList const& GetScopesData() const;
+  virtual ScopeData::Ptr GetScopeDataById(std::string const& scope_id) const;
+
+  static GSettingsScopesReader::Ptr GetDefault();
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+
+class GSettingsScopes : public Scopes
+{
+public:
+  GSettingsScopes();
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // UNITY_GSETTINGS_SCOPES_H
 \ No newline at end of file
 
=== added file 'UnityCore/MiscUtils.h'
--- UnityCore/MiscUtils.h	1970-01-01 00:00:00 +0000
+++ UnityCore/MiscUtils.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,118 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef UNITY_MISC_UTILS_H
+#define UNITY_MISC_UTILS_H
+
+#include <NuxCore/Property.h>
+
+namespace unity
+{
+namespace utils
+{
+
+template <typename TYPE>
+std::shared_ptr<sigc::connection> ConnectProperties(nux::ROProperty<TYPE>& local_property, nux::Property<TYPE>& remote_property)
+{
+  auto change_connection = std::make_shared<sigc::connection>();
+  local_property.SetGetterFunction([&remote_property]() { return remote_property.Get(); });
+  *change_connection = remote_property.changed.connect([&local_property, &remote_property](TYPE const& value) { local_property.EmitChanged(value); });
+  return change_connection;
+}
+
+template <typename TYPE>
+std::shared_ptr<sigc::connection> ConnectProperties(nux::ROProperty<TYPE>& local_property, nux::ROProperty<TYPE>& remote_property)
+{
+  auto change_connection = std::make_shared<sigc::connection>();
+  local_property.SetGetterFunction([&remote_property]() { return remote_property.Get(); });
+  *change_connection = remote_property.changed.connect([&local_property, &remote_property](TYPE const& value) { local_property.EmitChanged(value); });
+  return change_connection;
+}
+
+template <typename TYPE>
+std::shared_ptr<sigc::connection> ConnectProperties(nux::RWProperty<TYPE>& local_property, nux::Property<TYPE>& remote_property)
+{  
+  auto change_connection = std::make_shared<sigc::connection>();
+  *change_connection = remote_property.changed.connect([&local_property, &remote_property](TYPE const& value)
+  {
+    local_property.EmitChanged(value);
+  });
+
+  local_property.SetGetterFunction([&remote_property]() { return remote_property.Get(); });
+  local_property.SetSetterFunction([&remote_property, &local_property, change_connection](TYPE const& value)
+  {
+    TYPE old_value = remote_property.Get();
+
+    // block so we doing get a loop.
+    bool blocked = change_connection->block(true);
+    bool ret = remote_property.Set(value) != old_value;
+    change_connection->block(blocked);
+    return ret;
+  });
+  return change_connection;
+}
+
+template <typename TYPE>
+std::shared_ptr<sigc::connection> ConnectProperties(nux::RWProperty<TYPE>& local_property, nux::RWProperty<TYPE>& remote_property)
+{  
+  auto change_connection = std::make_shared<sigc::connection>();
+  *change_connection = remote_property.changed.connect([&local_property, &remote_property](TYPE const& value)
+  {
+    local_property.EmitChanged(value);
+  });
+
+  local_property.SetGetterFunction([&remote_property]() { return remote_property.Get(); });
+  local_property.SetSetterFunction([&remote_property, &local_property, change_connection](TYPE const& value)
+  {
+    TYPE old_value = remote_property.Get();
+
+    // block so we doing get a loop.
+    bool blocked = change_connection->block(true);
+    bool ret = remote_property.Set(value) != old_value;
+    change_connection->block(blocked);
+    return ret;
+  });
+  return change_connection;
+}
+
+template <class TYPE>
+class AutoResettingVariable
+{
+public:
+  AutoResettingVariable(TYPE*const variable, TYPE const& new_value)
+  : variable_(variable)
+  , original_value_(*variable)
+  {
+    *variable_ = new_value;
+  }
+
+  ~AutoResettingVariable()
+  {
+    *variable_ = original_value_;
+  }
+
+private:
+  TYPE*const variable_;
+  TYPE original_value_;
+};
+
+}
+}
+
+#endif // UNITY_MISC_UTILS_H
 \ No newline at end of file
 
=== modified file 'UnityCore/Model-inl.h'
--- UnityCore/Model-inl.h	2012-10-29 09:34:54 +0000
+++ UnityCore/Model-inl.h	2013-02-21 10:37:29 +0000
@@ -28,16 +28,6 @@
 {
 
 template<class RowAdaptor>
-Model<RowAdaptor>::Model()
-  : model_type_(ModelType::REMOTE)
-  , cached_adaptor1_(nullptr, nullptr, nullptr)
-  , cached_adaptor2_(nullptr, nullptr, nullptr)
-  , cached_adaptor3_(nullptr, nullptr, nullptr)
-{
-  Init();
-}
-
-template<class RowAdaptor>
 Model<RowAdaptor>::Model (ModelType model_type)
   : model_type_(model_type)
   , cached_adaptor1_(nullptr, nullptr, nullptr)
@@ -63,26 +53,66 @@
 void Model<RowAdaptor>::OnSwarmNameChanged(std::string const& swarm_name)
 {
   static nux::logging::Logger local_logger("unity.dash.model");
-
+  LOG_DEBUG(local_logger) << "New swarm name: " << swarm_name;
+
+  glib::Object<DeeModel> new_model;
+
+  switch(model_type_)
+  {
+    case ModelType::LOCAL:
+      new_model = dee_sequence_model_new();
+      break;
+
+    case ModelType::REMOTE:
+    case ModelType::REMOTE_SHARED:
+      new_model = dee_shared_model_new(swarm_name.c_str());
+      break;
+
+    case ModelType::UNATTACHED:
+      break;
+
+    default:
+      LOG_ERROR(local_logger) <<  "Unexpected ModelType " << model_type_;
+      break;
+  }
+
+  SetModel(new_model);
+}
+
+template<class RowAdaptor>
+void Model<RowAdaptor>::SetModel(glib::Object<DeeModel> const& new_model)
+{
+  GetDeeTagFunc func = [](glib::Object<DeeModel> const& model) {
+    return dee_model_register_tag(model, NULL); 
+  };
+  SetModel(new_model, func);
+}
+
+template<class RowAdaptor>
+void Model<RowAdaptor>::SetModel(glib::Object<DeeModel> const& new_model, GetDeeTagFunc const& get_dee_tag_func)
+{
+  typedef glib::Signal<void, DeeModel*, guint64, guint64> TransactionSignalType;
   typedef glib::Signal<void, DeeModel*, DeeModelIter*> RowSignalType;
-  typedef glib::Signal<void, DeeModel*, guint64, guint64> TransactionSignalType;
 
-  LOG_DEBUG(local_logger) << "New swarm name: " << swarm_name;
+  // Check if it's the same as the current model.
+  if (new_model == model_)
+    return;
 
   // Let the views clean up properly
   if (model_)
   {
     dee_model_clear(model_);
     sig_manager_.Disconnect(model_);
+    model_.Release();
   }
+  model_ = new_model;
+
+  if (!model_)
+    return;
 
   switch(model_type_)
   {
-    case ModelType::LOCAL:
-      model_ = dee_sequence_model_new();
-      break;
-    case ModelType::REMOTE:
-      model_ = dee_shared_model_new(swarm_name.c_str());
+    case ModelType::REMOTE_SHARED:
       sig_manager_.Add(new TransactionSignalType(model_,
                                                  "begin-transaction",
                                                  sigc::mem_fun(this, &Model<RowAdaptor>::OnTransactionBegin)));
@@ -91,15 +121,15 @@
                                                  "end-transaction",
                                                  sigc::mem_fun(this, &Model<RowAdaptor>::OnTransactionEnd)));
       break;
+
+    case ModelType::REMOTE:
+    case ModelType::LOCAL:
+    case ModelType::UNATTACHED:
     default:
-      LOG_ERROR(local_logger) <<  "Unexpected ModelType " << model_type_;
       break;
   }
 
-  model.EmitChanged(model_);
-
-
-  renderer_tag_ = dee_model_register_tag(model_, NULL);
+  renderer_tag_ = get_dee_tag_func(model_);
 
   sig_manager_.Add(new RowSignalType(model_,
                                      "row-added",
@@ -112,6 +142,8 @@
   sig_manager_.Add(new RowSignalType(model_,
                                      "row-removed",
                                      sigc::mem_fun(this, &Model<RowAdaptor>::OnRowRemoved)));
+
+  model.EmitChanged(model_);
 }
 
 template<class RowAdaptor>
 
=== modified file 'UnityCore/Model.h'
--- UnityCore/Model.h	2012-09-02 20:34:37 +0000
+++ UnityCore/Model.h	2013-02-21 10:37:29 +0000
@@ -38,7 +38,9 @@
 enum ModelType
 {
   REMOTE,
-  LOCAL
+  REMOTE_SHARED,
+  LOCAL,
+  UNATTACHED
 };
 
 /* This template class encapsulates the basics of talking to a DeeSharedModel,
@@ -52,14 +54,14 @@
 public:
   typedef std::shared_ptr<Model> Ptr;
 
-  Model();
-  Model (ModelType model_type);
+  Model (ModelType model_type = ModelType::REMOTE_SHARED);
   virtual ~Model();
 
   const RowAdaptor RowAtIndex(std::size_t index);
   DeeModelTag*     GetTag();
 
   nux::Property<std::string> swarm_name;
+
   nux::ROProperty<std::size_t> count;
   nux::ROProperty<unsigned long long> seqnum;
   nux::ROProperty<glib::Object<DeeModel>> model;
@@ -71,6 +73,11 @@
   sigc::signal<void, unsigned long long, unsigned long long> begin_transaction;
   sigc::signal<void, unsigned long long, unsigned long long> end_transaction;
 
+  typedef std::function<DeeModelTag*(glib::Object<DeeModel> const& model)> GetDeeTagFunc;
+
+  void SetModel(glib::Object<DeeModel> const& model);
+  void SetModel(glib::Object<DeeModel> const& model, GetDeeTagFunc const& func);
+
 private:
   void Init();
   void OnRowAdded(DeeModel* model, DeeModelIter* iter);
@@ -94,8 +101,8 @@
   RowAdaptor cached_adaptor3_;
 };
 
-}
-}
+} // namespace dash
+} // namespace unity
 
 #include "Model-inl.h"
 
 
=== modified file 'UnityCore/MusicPreview.cpp'
--- UnityCore/MusicPreview.cpp	2012-07-12 16:36:54 +0000
+++ UnityCore/MusicPreview.cpp	2013-02-21 10:37:29 +0000
@@ -22,11 +22,13 @@
 
 #include "MusicPreview.h"
 #include "Tracks.h"
+#include "Scope.h"
 
 namespace unity
 {
 namespace dash
 {
+DECLARE_LOGGER(logger, "unity.dash.musicpreview");
 
 class MusicPreview::Impl
 {
@@ -70,7 +72,12 @@
   unity_protocol_music_preview_play_uri(raw_preview_, uri.c_str());
   glib::Variant properties(unity_protocol_preview_end_updates(preview),
                            glib::StealRef());
-  owner_->Update(properties);
+
+  glib::HintsMap property_hints;
+  if (properties.ASVToHints(property_hints))
+    owner_->Update(property_hints);
+  else
+    LOG_ERROR(logger) << "PlayUri could not convert property hints to variant for " << uri;
 }
 
 void MusicPreview::Impl::PauseUri(std::string const& uri) const
@@ -81,7 +88,12 @@
   unity_protocol_music_preview_pause_uri(raw_preview_, uri.c_str());
   glib::Variant properties(unity_protocol_preview_end_updates(preview),
                            glib::StealRef());
-  owner_->Update(properties);
+
+  glib::HintsMap property_hints;
+  if (properties.ASVToHints(property_hints))
+    owner_->Update(property_hints);
+  else
+    LOG_ERROR(logger) << "PauseUri could not convert property hints to variant for " << uri;
 }
 
 MusicPreview::MusicPreview(unity::glib::Object<GObject> const& proto_obj)
 
=== modified file 'UnityCore/Preview.cpp'
--- UnityCore/Preview.cpp	2012-10-29 09:34:54 +0000
+++ UnityCore/Preview.cpp	2013-02-21 10:37:29 +0000
@@ -21,8 +21,8 @@
 #include <NuxCore/Logger.h>
 #include <unity-protocol.h>
 
-#include "Lens.h"
 #include "Preview.h"
+#include "Scope.h"
 
 #include "ApplicationPreview.h"
 #include "GenericPreview.h"
@@ -81,7 +81,7 @@
   return nullptr;
 }
 
-Preview::Ptr Preview::PreviewForVariant(glib::Variant &properties)
+Preview::Ptr Preview::PreviewForVariant(glib::Variant const& properties)
 {
   glib::Object<UnityProtocolPreview> preview(unity_protocol_preview_parse(properties));
   if (!preview)
@@ -123,10 +123,10 @@
   InfoHintPtrList get_info_hints() const { return info_hint_list_; };
   void EmitClosed() const;
 
-  Lens* get_parent_lens() const { return parent_lens_; };
-  bool set_parent_lens(Lens* lens)
+  Scope* get_parent_scope() const { return parent_scope_; };
+  bool set_parent_scope(Scope* scope)
   {
-    parent_lens_ = lens;
+    parent_scope_ = scope;
     return false; // TODO: do we need the notifications here?
   };
 
@@ -141,12 +141,12 @@
   std::string image_source_uri_;
   ActionPtrList actions_list_;
   InfoHintPtrList info_hint_list_;
-  Lens* parent_lens_;
+  Scope* parent_scope_;
 };
 
 Preview::Impl::Impl(Preview* owner, glib::Object<GObject> const& proto_obj)
   : owner_(owner)
-  , parent_lens_(nullptr)
+  , parent_scope_(nullptr)
 {
   if (!proto_obj)
   {
@@ -215,10 +215,10 @@
   owner_->image_source_uri.SetGetterFunction(
     sigc::mem_fun(this, &Preview::Impl::get_image_source_uri));
 
-  owner_->parent_lens.SetGetterFunction(
-      sigc::mem_fun(this, &Preview::Impl::get_parent_lens));
-  owner_->parent_lens.SetSetterFunction(
-      sigc::mem_fun(this, &Preview::Impl::set_parent_lens));
+  owner_->parent_scope.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_parent_scope));
+  owner_->parent_scope.SetSetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::set_parent_scope));
 }
 
 void Preview::Impl::EmitClosed() const
@@ -229,7 +229,12 @@
   unity_protocol_preview_preview_closed(raw_preview_);
   glib::Variant properties(unity_protocol_preview_end_updates(preview),
                            glib::StealRef());
-  owner_->Update(properties);
+
+  glib::HintsMap property_hints;
+  if (properties.ASVToHints(property_hints))
+    owner_->Update(property_hints);
+  else
+    LOG_ERROR(logger) << "EmitClosed could not convert property hints to variant for " << owner_->preview_uri.Get();
 }
 
 Preview::Preview(glib::Object<GObject> const& proto_obj)
@@ -251,28 +256,28 @@
   return pimpl->get_info_hints();
 }
 
-void Preview::Update(glib::Variant const& properties,
-                     glib::DBusProxy::ReplyCallback reply_callback) const
+void Preview::Update(glib::HintsMap const& property_hints,
+                     std::function<void(glib::HintsMap const&, glib::Error const&)> const& reply_callback) const
 {
-  if (pimpl->parent_lens_)
+  if (pimpl->parent_scope_)
   {
-    pimpl->parent_lens_->SignalPreview(preview_uri, properties, reply_callback);
+    pimpl->parent_scope_->UpdatePreviewProperty(preview_uri, property_hints, reply_callback);
   }
   else
   {
-    LOG_WARN(logger) << "Unable to update Preview, parent_lens wasn't set!";
+    LOG_WARN(logger) << "Unable to update Preview, parent_scope_ wasn't set!";
   }
 }
 
-void Preview::PerformAction(std::string const& id, Lens::Hints const& hints) const
+void Preview::PerformAction(std::string const& id, glib::HintsMap const& hints) const
 {
-  if (pimpl->parent_lens_)
+  if (pimpl->parent_scope_)
   {
-    pimpl->parent_lens_->ActivatePreviewAction(id, preview_uri, hints);
+    pimpl->parent_scope_->ActivatePreviewAction(id, preview_uri, hints);
   }
   else
   {
-    LOG_WARN(logger) << "Unable to perform action '" << id << "', parent_lens wasn't set!";
+    LOG_WARN(logger) << "Unable to perform action '" << id << "', parent_scope_ wasn't set!";
   }
 }
 
 
=== modified file 'UnityCore/Preview.h'
--- UnityCore/Preview.h	2012-09-13 10:56:42 +0000
+++ UnityCore/Preview.h	2013-02-21 10:37:29 +0000
@@ -40,7 +40,7 @@
 namespace dash
 {
 
-class Lens;
+class Scope;
 
 enum LayoutHint
 {
@@ -110,7 +110,7 @@
 
   virtual ~Preview();
 
-  static Preview::Ptr PreviewForVariant(glib::Variant& properties);
+  static Preview::Ptr PreviewForVariant(glib::Variant const& properties);
   static Preview::Ptr PreviewForProtocolObject(glib::Object<GObject> const& proto_obj);
 
   nux::ROProperty<std::string> renderer_name;
@@ -120,24 +120,24 @@
   nux::ROProperty<unity::glib::Object<GIcon>> image;
   nux::ROProperty<std::string> image_source_uri;
 
-  // can't use Lens::Ptr to avoid circular dependency
-  nux::RWProperty<Lens*> parent_lens;
+  // can't use Scope::Ptr to avoid circular dependency
+  nux::RWProperty<Scope*> parent_scope;
   nux::Property<std::string> preview_uri;
 
   ActionPtrList GetActions() const;
   InfoHintPtrList GetInfoHints() const;
 
   void PerformAction(std::string const& id,
-                     std::map<std::string, glib::Variant> const& hints =
-                     std::map<std::string, glib::Variant>()) const;
+                     glib::HintsMap const& hints =
+                     glib::HintsMap()) const;
   void EmitClosed() const;
 
 protected:
   // this should be UnityProtocolPreview, but we want to keep the usage
   // of libunity-protocol-private private to unity-core
   Preview(glib::Object<GObject> const& proto_obj);
-  void Update(glib::Variant const& properties,
-              glib::DBusProxy::ReplyCallback reply_callback = nullptr) const;
+  void Update(glib::HintsMap const& property_hints,
+              std::function<void(glib::HintsMap const&, glib::Error const&)> const& reply_callback = nullptr) const;
   static glib::Object<GIcon> IconForString(std::string const& icon_hint);
 
 private:
 
=== modified file 'UnityCore/Result.cpp'
--- UnityCore/Result.cpp	2012-12-06 17:41:07 +0000
+++ UnityCore/Result.cpp	2013-02-21 10:37:29 +0000
@@ -25,6 +25,22 @@
 namespace dash
 {
 
+namespace
+{
+enum ResultColumn
+{
+  URI,
+  ICON_HINT,
+  CATEGORY,
+  RESULT_TYPE,
+  MIMETYPE,
+  TITLE,
+  COMMENT,
+  DND_URI,
+  METADATA
+};
+}
+
 Result::Result(DeeModel* model,
                DeeModelIter* iter,
                DeeModelTag* renderer_tag)
@@ -51,19 +67,21 @@
   uri.SetGetterFunction(sigc::mem_fun(this, &Result::GetURI));
   icon_hint.SetGetterFunction(sigc::mem_fun(this, &Result::GetIconHint));
   category_index.SetGetterFunction(sigc::mem_fun(this, &Result::GetCategoryIndex));
+  result_type.SetGetterFunction(sigc::mem_fun(this, &Result::GetResultType));
   mimetype.SetGetterFunction(sigc::mem_fun(this, &Result::GetMimeType));
   name.SetGetterFunction(sigc::mem_fun(this, &Result::GetName));
   comment.SetGetterFunction(sigc::mem_fun(this, &Result::GetComment));
   dnd_uri.SetGetterFunction(sigc::mem_fun(this, &Result::GetDndURI));
 }
 
-std::string Result::GetURI() const { return GetStringAt(0); }
-std::string Result::GetIconHint() const { return GetStringAt(1); }
-std::size_t Result::GetCategoryIndex() const { return GetUIntAt(2); }
-std::string Result::GetMimeType() const { return GetStringAt(3); }
-std::string Result::GetName() const { return GetStringAt(4); }
-std::string Result::GetComment() const { return GetStringAt(5); }
-std::string Result::GetDndURI() const { return GetStringAt(6); }
+std::string Result::GetURI() const { return GetStringAt(ResultColumn::URI); }
+std::string Result::GetIconHint() const { return GetStringAt(ResultColumn::ICON_HINT); }
+unsigned Result::GetCategoryIndex() const { return GetUIntAt(ResultColumn::CATEGORY); }
+unsigned Result::GetResultType() const { return GetUIntAt(ResultColumn::RESULT_TYPE); }
+std::string Result::GetMimeType() const { return GetStringAt(ResultColumn::MIMETYPE); }
+std::string Result::GetName() const { return GetStringAt(ResultColumn::TITLE); }
+std::string Result::GetComment() const { return GetStringAt(ResultColumn::COMMENT); }
+std::string Result::GetDndURI() const { return GetStringAt(ResultColumn::DND_URI); }
 
 }
 }
 
=== modified file 'UnityCore/Result.h'
--- UnityCore/Result.h	2012-12-06 17:41:07 +0000
+++ UnityCore/Result.h	2013-02-21 10:37:29 +0000
@@ -45,7 +45,8 @@
 
   nux::ROProperty<std::string> uri;
   nux::ROProperty<std::string> icon_hint;
-  nux::ROProperty<std::size_t> category_index;
+  nux::ROProperty<unsigned> category_index;
+  nux::ROProperty<unsigned> result_type;
   nux::ROProperty<std::string> mimetype;
   nux::ROProperty<std::string> name;
   nux::ROProperty<std::string> comment;
@@ -54,7 +55,8 @@
 protected:
   virtual std::string GetURI() const;
   virtual std::string GetIconHint() const;
-  virtual std::size_t GetCategoryIndex() const;
+  virtual unsigned GetCategoryIndex() const;
+  virtual unsigned GetResultType() const;
   virtual std::string GetMimeType() const;
   virtual std::string GetName() const;
   virtual std::string GetComment() const;
 
=== modified file 'UnityCore/Results.cpp'
--- UnityCore/Results.cpp	2012-04-23 12:29:20 +0000
+++ UnityCore/Results.cpp	2013-02-21 10:37:29 +0000
@@ -25,6 +25,7 @@
 {
 
 Results::Results()
+: Model<Result>::Model(ModelType::REMOTE_SHARED)
 {
   row_added.connect(sigc::mem_fun(this, &Results::OnRowAdded));
   row_changed.connect(sigc::mem_fun(this, &Results::OnRowChanged));
 
=== added file 'UnityCore/Scope.cpp'
--- UnityCore/Scope.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/Scope.cpp	2013-02-21 10:37:29 +0000
@@ -0,0 +1,211 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ *
+ */
+
+#include "Scope.h"
+#include "MiscUtils.h"
+#include "ScopeProxy.h"
+#include <unity-protocol.h>
+
+
+namespace unity
+{
+namespace dash
+{
+DECLARE_LOGGER(logger, "unity.dash.scope");
+
+class Scope::Impl
+{
+public:
+  Impl(Scope* owner, ScopeData::Ptr const& scope_data);
+  ~Impl();
+
+  void Init();
+
+  void Activate(std::string const& uri, guint action_type, glib::HintsMap const& hints, ActivateCallback const& callback, GCancellable* cancellable);
+  void OnActivateReply(std::string const& uri, ScopeHandledType handled_type, glib::HintsMap const& hints, glib::Error const& error);
+
+  DeeFilter* GetFilterForCategory(unsigned category, DeeFilter* filter)  const;
+
+  Scope* owner_;
+  ScopeData::Ptr scope_data_;
+  ScopeProxyInterface::Ptr proxy_;
+
+  typedef std::shared_ptr<sigc::connection> ConnectionPtr;
+  std::vector<ConnectionPtr> property_connections;
+};
+
+Scope::Impl::Impl(Scope* owner, ScopeData::Ptr const& scope_data)
+: owner_(owner)
+, scope_data_(scope_data)
+{
+  property_connections.push_back(utils::ConnectProperties(owner_->id, scope_data_->id));
+}
+
+Scope::Impl::~Impl()
+{
+  for_each(property_connections.begin(), property_connections.end(), [](ConnectionPtr const& con) { con->disconnect(); });
+  property_connections.clear();
+}
+
+void Scope::Impl::Init()
+{
+  proxy_ = owner_->CreateProxyInterface();
+
+  if (proxy_)
+  {
+    property_connections.push_back(utils::ConnectProperties(owner_->connected, proxy_->connected));
+    property_connections.push_back(utils::ConnectProperties(owner_->is_master, proxy_->is_master));
+    property_connections.push_back(utils::ConnectProperties(owner_->search_in_global, proxy_->search_in_global));
+    property_connections.push_back(utils::ConnectProperties(owner_->search_hint, proxy_->search_hint));
+    property_connections.push_back(utils::ConnectProperties(owner_->view_type, proxy_->view_type));
+    property_connections.push_back(utils::ConnectProperties(owner_->results, proxy_->results));
+    property_connections.push_back(utils::ConnectProperties(owner_->filters, proxy_->filters));
+    property_connections.push_back(utils::ConnectProperties(owner_->categories, proxy_->categories));
+    property_connections.push_back(utils::ConnectProperties(owner_->category_order, proxy_->category_order));
+
+    property_connections.push_back(utils::ConnectProperties(owner_->name, proxy_->name));
+    property_connections.push_back(utils::ConnectProperties(owner_->description, proxy_->description));
+    property_connections.push_back(utils::ConnectProperties(owner_->icon_hint, proxy_->icon_hint));
+    property_connections.push_back(utils::ConnectProperties(owner_->category_icon_hint, proxy_->category_icon_hint));
+    property_connections.push_back(utils::ConnectProperties(owner_->keywords, proxy_->keywords));
+    property_connections.push_back(utils::ConnectProperties(owner_->type, proxy_->type));
+    property_connections.push_back(utils::ConnectProperties(owner_->query_pattern, proxy_->query_pattern));
+    property_connections.push_back(utils::ConnectProperties(owner_->shortcut, proxy_->shortcut));
+    property_connections.push_back(utils::ConnectProperties(owner_->visible, proxy_->visible));
+
+    property_connections.push_back(utils::ConnectProperties(owner_->results, proxy_->results));
+    property_connections.push_back(utils::ConnectProperties(owner_->filters, proxy_->filters));
+    property_connections.push_back(utils::ConnectProperties(owner_->categories, proxy_->categories));
+  }
+}
+
+void Scope::Impl::Activate(std::string const& uri, guint action_type, glib::HintsMap const& hints, ActivateCallback const& callback, GCancellable* cancellable)
+{
+  proxy_->Activate(uri,
+                   action_type,
+                   hints,
+                   [this, callback] (std::string const& uri, ScopeHandledType handled_type, glib::HintsMap const& hints, glib::Error const& error) {
+      if (callback)
+        callback(uri, handled_type, error);
+      OnActivateReply(uri, handled_type, hints, error);
+    },
+    cancellable);
+}
+
+
+void Scope::Impl::OnActivateReply(std::string const& uri, ScopeHandledType handled, glib::HintsMap const& hints, glib::Error const& error)
+{
+  LOG_DEBUG(logger) << "Activation reply (handled:" << handled << ", error: " << (error ? "true" : "false") << ") for " <<  uri;
+
+  if (static_cast<UnityProtocolHandledType>(handled) == UNITY_PROTOCOL_HANDLED_TYPE_SHOW_PREVIEW)
+  {
+    auto iter = hints.find("preview");
+    if (iter != hints.end())
+    {
+      glib::Variant v = iter->second;
+
+      Preview::Ptr preview(Preview::PreviewForVariant(v));
+      if (preview)
+      {
+        // would be nice to make parent_scope_ a shared_ptr,
+        // but that's not really doable from here
+        preview->parent_scope = owner_;
+        preview->preview_uri = uri;
+        owner_->preview_ready.emit(uri, preview);
+        return;
+      }
+    }
+
+    LOG_WARNING(logger) << "Unable to deserialize Preview";
+  }
+  else
+  {
+    owner_->activated.emit(uri, handled, hints);
+  }
+}
+
+Scope::Scope(ScopeData::Ptr const& scope_data)
+: pimpl(new Impl(this, scope_data))
+{
+}
+
+Scope::~Scope()
+{
+}
+
+void Scope::Init()
+{
+  pimpl->Init();
+}
+
+void Scope::Connect()
+{
+  if (pimpl->proxy_->connected())
+    return;
+  
+  pimpl->proxy_->CreateProxy();
+}
+
+void Scope::Search(std::string const& search_hint, SearchCallback const& callback, GCancellable* cancellable)
+{
+  return pimpl->proxy_->Search(search_hint, callback, cancellable);
+}
+
+void Scope::Activate(std::string const& uri, ActivateCallback const& callback, GCancellable* cancellable)
+{
+  pimpl->Activate(uri, UNITY_PROTOCOL_ACTION_TYPE_ACTIVATE_RESULT, glib::HintsMap(), callback, cancellable);
+}
+
+void Scope::Preview(std::string const& uri, ActivateCallback const& callback, GCancellable* cancellable)
+{
+  pimpl->Activate(uri, UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_RESULT, glib::HintsMap(), callback, cancellable);
+}
+
+void Scope::ActivatePreviewAction(std::string const& action_id,
+                                   std::string const& uri,
+                                   glib::HintsMap const& hints,
+                                   ActivateCallback const& callback,
+                                   GCancellable* cancellable)
+{
+  std::string activation_uri(action_id);
+  activation_uri += ":";
+  activation_uri += uri;
+
+  pimpl->Activate(activation_uri, UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION, hints, callback, cancellable);
+}
+
+void Scope::UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, UpdatePreviewPropertyCallback const& callback, GCancellable* cancellable)
+{
+  pimpl->proxy_->UpdatePreviewProperty(uri, glib::HintsMap(), callback, cancellable);
+}
+
+Results::Ptr Scope::GetResultsForCategory(unsigned category) const
+{
+  return pimpl->proxy_->GetResultsForCategory(category);
+}
+
+ScopeProxyInterface::Ptr Scope::CreateProxyInterface() const
+{
+  return ScopeProxyInterface::Ptr(new ScopeProxy(pimpl->scope_data_));
+}
+
+
+} // namespace dash
+} // namespace unity
 
=== added file 'UnityCore/Scope.h'
--- UnityCore/Scope.h	1970-01-01 00:00:00 +0000
+++ UnityCore/Scope.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef UNITY_SCOPE_H
+#define UNITY_SCOPE_H
+
+#include <boost/noncopyable.hpp>
+#include <sigc++/trackable.h>
+
+#include "ScopeProxyInterface.h"
+#include "Preview.h"
+#include "Result.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class Scope : public sigc::trackable, boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<Scope> Ptr;
+
+  Scope(ScopeData::Ptr const& scope_data);
+  virtual ~Scope();
+
+  // Must call this function after construction.
+  virtual void Init();
+
+  void Connect();
+
+  nux::ROProperty<std::string> id;
+  nux::ROProperty<bool> connected;
+
+  nux::ROProperty<bool> visible;
+  nux::ROProperty<bool> is_master;
+  nux::ROProperty<bool> search_in_global;
+  nux::ROProperty<std::string> search_hint;
+  nux::RWProperty<ScopeViewType> view_type;
+
+  nux::ROProperty<Results::Ptr> results;
+  nux::ROProperty<Filters::Ptr> filters;
+  nux::ROProperty<Categories::Ptr> categories;
+  nux::ROProperty<std::vector<int>> category_order;
+
+  nux::ROProperty<std::string> name;
+  nux::ROProperty<std::string> description;
+  nux::ROProperty<std::string> icon_hint;
+  nux::ROProperty<std::string> category_icon_hint;
+  nux::ROProperty<std::vector<std::string>> keywords;
+  nux::ROProperty<std::string> type;
+  nux::ROProperty<std::string> query_pattern;
+  nux::ROProperty<std::string> shortcut;
+
+  typedef std::function<void(glib::HintsMap const&, glib::Error const&)> SearchCallback;
+  virtual void Search(std::string const& search_hint, SearchCallback const& callback = nullptr, GCancellable* cancellable = nullptr);
+
+  typedef std::function<void(std::string const&, ScopeHandledType, glib::Error const&)> ActivateCallback;
+
+  virtual void Activate(std::string const& uri, ActivateCallback const& callback = nullptr, GCancellable* cancellable = nullptr);
+
+  virtual void Preview(std::string const& uri, ActivateCallback const& callback = nullptr, GCancellable* cancellable = nullptr);
+
+  virtual void ActivatePreviewAction(std::string const& action_id,
+                                     std::string const& uri,
+                                     glib::HintsMap const& hints,
+                                     ActivateCallback const& callback = nullptr,
+                                     GCancellable* cancellable = nullptr);
+
+  typedef std::function<void(glib::HintsMap const&, glib::Error const&)> UpdatePreviewPropertyCallback;
+  virtual void UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, UpdatePreviewPropertyCallback const& callback = nullptr, GCancellable* cancellable = nullptr);
+
+  virtual Results::Ptr GetResultsForCategory(unsigned category) const;
+
+
+  sigc::signal<void, std::string const&, ScopeHandledType, glib::HintsMap const&> activated;
+  sigc::signal<void, std::string const&, Preview::Ptr const&> preview_ready;
+
+protected:
+  virtual ScopeProxyInterface::Ptr CreateProxyInterface() const;
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // UNITY_SCOPE_H
 \ No newline at end of file
 
=== added file 'UnityCore/ScopeData.cpp'
--- UnityCore/ScopeData.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/ScopeData.cpp	2013-02-21 10:37:29 +0000
@@ -0,0 +1,89 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+
+#include "ScopeData.h"
+#include <unity-protocol.h>
+#include <NuxCore/Logger.h>
+
+#include "GLibWrapper.h"
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+  static void safe_delete_scope_metadata(UnityProtocolScopeRegistryScopeMetadata* data)
+  {
+    if (!data) return;
+    unity_protocol_scope_registry_scope_metadata_unref(data);
+  }
+}
+
+ScopeData::ScopeData()
+: visible(true)
+{
+}
+
+ScopeData::Ptr ScopeData::ReadProtocolDataForId(std::string const& scope_id, glib::Error& error)
+{
+  ScopeData::Ptr data(new ScopeData());
+
+  std::shared_ptr<UnityProtocolScopeRegistryScopeMetadata> meta_data(unity_protocol_scope_registry_scope_metadata_for_id(scope_id.c_str(), &error),
+                                                                     safe_delete_scope_metadata);
+
+  if (error)
+  {
+    data->id = scope_id;
+  }
+  else if (meta_data)
+  {
+    data->dbus_name = glib::gchar_to_string(meta_data->dbus_name);
+    data->dbus_path = glib::gchar_to_string(meta_data->dbus_path);
+
+    data->id = glib::gchar_to_string(meta_data->id);
+    data->full_path = glib::gchar_to_string(meta_data->full_path);
+    data->name = glib::gchar_to_string(meta_data->name);
+    data->icon_hint = glib::gchar_to_string(meta_data->icon);
+    data->category_icon_hint = glib::gchar_to_string(meta_data->category_icon);
+    data->type = meta_data->type;
+    data->description = glib::gchar_to_string(meta_data->description);
+    data->shortcut = glib::gchar_to_string(meta_data->shortcut);
+    data->search_hint = glib::gchar_to_string(meta_data->search_hint);
+    data->is_master = meta_data->is_master;
+    data->query_pattern = glib::gchar_to_string(meta_data->query_pattern);
+
+    std::vector<std::string> keywords;
+    for (GSList* v = meta_data->keywords; v; v = g_slist_next(v))
+    {
+      std::string value(static_cast<gchar*>(v->data));
+      if (value.empty())
+        continue;
+
+      keywords.push_back(value);
+    }
+    data->keywords = keywords;
+  }
+  return data;
+}
+
+}
+}
 \ No newline at end of file
 
=== added file 'UnityCore/ScopeData.h'
--- UnityCore/ScopeData.h	1970-01-01 00:00:00 +0000
+++ UnityCore/ScopeData.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,68 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+
+#ifndef UNITY_SCOPE_DATA_H
+#define UNITY_SCOPE_DATA_H
+
+#include <NuxCore/Property.h>
+#include "GLibWrapper.h"
+
+namespace unity
+{
+namespace dash
+{
+
+enum ScopeViewType
+{
+  HIDDEN=0,
+  HOME_VIEW,
+  SCOPE_VIEW
+};
+
+class ScopeData
+{
+public:
+  typedef std::shared_ptr<ScopeData> Ptr;
+  ScopeData();
+
+  nux::Property<std::string> id;
+  nux::Property<std::string> full_path;
+  nux::Property<std::string> dbus_name;
+  nux::Property<std::string> dbus_path;
+  nux::Property<bool> is_master;
+  nux::Property<std::string> icon_hint;
+  nux::Property<std::string> category_icon_hint;
+  nux::Property<std::vector<std::string>> keywords;
+  nux::Property<std::string> type;
+  nux::Property<std::string> query_pattern;
+  nux::Property<std::string> name;
+  nux::Property<std::string> description;
+  nux::Property<std::string> shortcut;
+  nux::Property<std::string> search_hint;
+  
+  nux::Property<bool> visible; // FIXME!
+
+  static ScopeData::Ptr ReadProtocolDataForId(std::string const& scope_id, glib::Error& error);
+};
+
+}
+}
+
+#endif 
 \ No newline at end of file
 
=== added file 'UnityCore/ScopeProxy.cpp'
--- UnityCore/ScopeProxy.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/ScopeProxy.cpp	2013-02-21 10:37:29 +0000
@@ -0,0 +1,804 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include "ScopeProxy.h"
+#include "GLibSignal.h"
+#include "MiscUtils.h"
+
+#include <unity-protocol.h>
+#include <NuxCore/Logger.h>
+#include "GLibSource.h"
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+const int PROXY_CONNECT_TIMEOUT = 2000;
+
+const unsigned CATEGORY_COLUMN = 2;
+}
+
+
+DECLARE_LOGGER(logger, "unity.dash.scopeproxy");
+
+class ScopeProxy::Impl
+{
+public:
+  Impl(ScopeProxy*const owner, ScopeData::Ptr const& scope_data);
+  ~Impl();
+
+  static ScopeData::Ptr CreateData(std::string const& dbus_name, std::string const& dbus_path);
+
+  void CreateProxy();
+  void OnNewScope(GObject *source_object, GAsyncResult *res);
+  void DestroyProxy();
+
+  void OpenChannel();
+  void OnChannelOpened(GObject *source_object, GAsyncResult *res);
+
+  void CloseChannel();
+  static void OnCloseChannel(GObject *source_object, GAsyncResult *res, gpointer user_data);
+
+  void Search(std::string const& search_string, glib::HintsMap const& hints, SearchCallback const& callback, GCancellable* cancel);
+  void Activate(std::string const& uri, uint activate_type, glib::HintsMap const& hints, ScopeProxy::ActivateCallback const& callback, GCancellable* cancellable);
+  void UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, UpdatePreviewPropertyCallback const& callback, GCancellable* cancellable);
+
+  bool set_view_type(ScopeViewType const& view_type)
+  {
+    if (scope_proxy_ && unity_protocol_scope_proxy_get_view_type(scope_proxy_) != static_cast<UnityProtocolViewType>(view_type))
+    {
+      unity_protocol_scope_proxy_set_view_type(scope_proxy_, static_cast<UnityProtocolViewType>(view_type));
+      return true;
+    }
+    return false;
+  }
+
+  Results::Ptr results() { return results_; }
+  Filters::Ptr filters() { return filters_; }
+  Categories::Ptr categories() { return categories_; }
+
+  DeeFilter* GetFilterForCategory(unsigned category, DeeFilter* filter) const;
+
+  ScopeProxy*const owner_;
+  ScopeData::Ptr scope_data_;
+
+  // scope proxy properties
+  nux::Property<bool> search_in_global;
+  nux::Property<ScopeViewType> view_type;
+
+  nux::Property<bool> connected;
+  nux::Property<std::string> channel;
+  nux::Property<std::vector<int>> category_order;
+  std::string last_search_;
+
+  glib::Object<UnityProtocolScopeProxy> scope_proxy_;
+  glib::Object<GCancellable> cancel_scope_;
+  bool proxy_created_;
+  bool scope_proxy_connected_;
+  bool searching_;
+
+  Results::Ptr results_;
+  Filters::Ptr filters_;
+  Categories::Ptr categories_;
+
+  typedef std::shared_ptr<sigc::connection> ConnectionPtr;
+  std::vector<ConnectionPtr> property_connections;
+  sigc::connection filters_change_connection;
+
+  /////////////////////////////////////////////////
+  // DBus property signals.
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> connected_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> search_in_global_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> is_master_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> search_hint_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> view_type_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> filters_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> categories_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> metadata_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, GParamSpec*> optional_metadata_signal_;
+  glib::Signal<void, UnityProtocolScopeProxy*, const gchar*, guint32*, int> category_order_signal_;
+  /////////////////////////////////////////////////
+
+private:
+  /////////////////////////////////////////////////
+  // Signal Connections
+  void OnScopeConnectedChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeIsMasterChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeSearchInGlobalChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeSearchHintChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeViewTypeChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeFiltersChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeCategoriesChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeMetadataChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeOptionalMetadataChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param);
+  void OnScopeCategoryOrderChanged(UnityProtocolScopeProxy* sender, const gchar* channel_id, guint32* new_order, int new_order_length1);
+  /////////////////////////////////////////////////
+
+  void WaitForProxyConnection(GCancellable* cancellable,
+                                   int timeout_msec,
+                                   std::function<void(glib::Error const&)> const& callback);
+
+  /////////////////////////////////////
+  // Search Callback
+  struct SearchData
+  {
+    SearchCallback callback;
+  };
+
+  static void OnScopeSearchCallback(GObject *source_object, GAsyncResult *res, gpointer user_data)
+  {
+    std::unique_ptr<SearchData> data(static_cast<SearchData*>(user_data));
+    glib::Error error;
+    GHashTable* hint_ret = unity_protocol_scope_proxy_search_finish(UNITY_PROTOCOL_SCOPE_PROXY(source_object), res, &error);
+
+    glib::HintsMap hints;
+    glib::hintsmap_from_hashtable(hint_ret, hints);
+
+    if (data->callback)
+      data->callback(hints, error);
+    if (hint_ret) { g_hash_table_destroy(hint_ret); }
+  }
+  /////////////////////////////////////
+
+  /////////////////////////////////////
+  // Search Callback
+  struct UpdatePreviewPropertyData
+  {
+    UpdatePreviewPropertyCallback callback;
+  };
+
+  static void OnScopeUpdatePreviewPropertyCallback(GObject *source_object, GAsyncResult *res, gpointer user_data)
+  {
+    std::unique_ptr<UpdatePreviewPropertyData> data(static_cast<UpdatePreviewPropertyData*>(user_data));
+    glib::Error error;
+    GHashTable* hint_ret = unity_protocol_scope_proxy_update_preview_property_finish(UNITY_PROTOCOL_SCOPE_PROXY(source_object), res, &error);
+
+    glib::HintsMap hints;
+    glib::hintsmap_from_hashtable(hint_ret, hints);
+
+    if (data->callback)
+      data->callback(hints, error);
+
+    if (hint_ret) { g_hash_table_destroy(hint_ret); }
+  }
+  /////////////////////////////////////
+
+  /////////////////////////////////////
+  // Activation Callback
+  struct ActivateData
+  {
+    ScopeProxy::ActivateCallback callback;
+  };
+  static void OnScopeActivateCallback(GObject *source_object, GAsyncResult *res, gpointer user_data)
+  {
+    std::unique_ptr<ActivateData> data(static_cast<ActivateData*>(user_data));
+    UnityProtocolActivationReplyRaw result;
+    glib::Error error;
+    unity_protocol_scope_proxy_activate_finish(UNITY_PROTOCOL_SCOPE_PROXY(source_object), res, &result, &error);
+
+    if (data->callback)
+    {
+      std::string uri;
+      ScopeHandledType handled = ScopeHandledType::NOT_HANDLED;
+
+      uri = result.uri;
+      handled = static_cast<ScopeHandledType>(result.handled);
+
+      glib::HintsMap hints;
+      glib::hintsmap_from_hashtable(result.hints, hints);
+
+      data->callback(uri, handled, hints, error);
+    }
+  }
+  /////////////////////////////////////
+
+  /////////////////////////////////////
+  // Async Calls
+  struct ScopeAyncReplyData
+  {
+    typedef std::function<void(GObject *source_object, GAsyncResult *res)> ScopeAsyncReplyCallback;
+    ScopeAyncReplyData(ScopeAsyncReplyCallback const& callback): callback(callback) {}
+
+    ScopeAsyncReplyCallback callback;
+  };
+  static void OnScopeAsyncCallback(GObject *source_object, GAsyncResult *res, gpointer user_data)
+  {
+    std::unique_ptr<ScopeAyncReplyData> data(static_cast<ScopeAyncReplyData*>(user_data));
+    if (data->callback)
+      data->callback(source_object, res);    
+  }
+  /////////////////////////////////////
+};
+
+
+ScopeProxy::Impl::Impl(ScopeProxy*const owner, ScopeData::Ptr const& scope_data)
+: owner_(owner)
+, scope_data_(scope_data)
+, search_in_global(false)
+, view_type(ScopeViewType::HIDDEN)
+, connected(false)
+, cancel_scope_(g_cancellable_new())
+, proxy_created_(false)
+, scope_proxy_connected_(false)
+, searching_(false)
+, results_(new Results())
+, filters_(new Filters())
+, categories_(new Categories())
+{
+  // remote properties
+  property_connections.push_back(utils::ConnectProperties(owner_->connected, connected));
+  property_connections.push_back(utils::ConnectProperties(owner_->channel, channel));
+  property_connections.push_back(utils::ConnectProperties(owner_->search_in_global, search_in_global));
+  property_connections.push_back(utils::ConnectProperties(owner_->view_type, view_type));
+  property_connections.push_back(utils::ConnectProperties(owner_->category_order, category_order));
+
+  // shared properties
+  property_connections.push_back(utils::ConnectProperties(owner_->is_master, scope_data_->is_master));
+  property_connections.push_back(utils::ConnectProperties(owner_->search_hint, scope_data_->search_hint));
+  // local properties
+  property_connections.push_back(utils::ConnectProperties(owner_->dbus_name, scope_data_->dbus_name));
+  property_connections.push_back(utils::ConnectProperties(owner_->dbus_path, scope_data_->dbus_path));
+  property_connections.push_back(utils::ConnectProperties(owner_->name, scope_data_->name));
+  property_connections.push_back(utils::ConnectProperties(owner_->description, scope_data_->description));
+  property_connections.push_back(utils::ConnectProperties(owner_->shortcut, scope_data_->shortcut));
+  property_connections.push_back(utils::ConnectProperties(owner_->icon_hint, scope_data_->icon_hint));
+  property_connections.push_back(utils::ConnectProperties(owner_->category_icon_hint, scope_data_->category_icon_hint));
+  property_connections.push_back(utils::ConnectProperties(owner_->keywords, scope_data_->keywords));
+  property_connections.push_back(utils::ConnectProperties(owner_->type, scope_data_->type));
+  property_connections.push_back(utils::ConnectProperties(owner_->query_pattern, scope_data_->query_pattern));
+  property_connections.push_back(utils::ConnectProperties(owner_->visible, scope_data_->visible));
+  
+  owner_->filters.SetGetterFunction(sigc::mem_fun(this, &Impl::filters));
+  owner_->categories.SetGetterFunction(sigc::mem_fun(this, &Impl::categories));
+  owner_->results.SetGetterFunction(sigc::mem_fun(this, &Impl::results));
+}
+
+ScopeProxy::Impl::~Impl()
+{
+  filters_change_connection.disconnect();
+  for_each(property_connections.begin(), property_connections.end(), [](ConnectionPtr const& con) { con->disconnect(); });
+  property_connections.clear();
+
+  g_cancellable_cancel(cancel_scope_);
+
+  if (scope_proxy_ && connected)
+    unity_protocol_scope_proxy_close_channel(scope_proxy_, channel().c_str(), nullptr, Impl::OnCloseChannel, nullptr);
+}
+
+ScopeData::Ptr ScopeProxy::Impl::CreateData(std::string const& dbus_name, std::string const& dbus_path)
+{
+  ScopeData::Ptr data(new ScopeData);
+  data->dbus_path = dbus_path;
+  data->dbus_name = dbus_name;
+
+  return data;
+}
+
+void ScopeProxy::Impl::DestroyProxy()
+{
+  scope_proxy_.Release();
+  if (cancel_scope_)
+    g_cancellable_cancel(cancel_scope_);
+  
+  cancel_scope_ = g_cancellable_new(); 
+  connected = false;
+  proxy_created_ = false;
+}
+
+void ScopeProxy::Impl::CreateProxy()
+{
+  if (proxy_created_)
+    return;
+
+  proxy_created_ = true;
+  unity_protocol_scope_proxy_new_from_dbus(scope_data_->dbus_name().c_str(),
+                                           scope_data_->dbus_path().c_str(),
+                                           cancel_scope_,
+                                           Impl::OnScopeAsyncCallback,
+                                           new ScopeAyncReplyData(sigc::mem_fun(this, &Impl::OnNewScope)));
+}
+
+void ScopeProxy::Impl::OnNewScope(GObject *source_object, GAsyncResult *res)
+{ 
+  glib::Object<UnityProtocolScopeProxy> scope_proxy;
+  glib::Error error;
+  scope_proxy = unity_protocol_scope_proxy_new_from_dbus_finish(res, &error);
+
+  search_in_global_signal_.Disconnect();
+  is_master_signal_.Disconnect();
+  search_hint_signal_.Disconnect();
+  view_type_signal_.Disconnect();
+  filters_signal_.Disconnect();
+  categories_signal_.Disconnect();
+  metadata_signal_.Disconnect();
+  optional_metadata_signal_.Disconnect();
+
+
+  if (error || !scope_proxy)
+  {
+    scope_proxy_.Release();
+    LOG_ERROR(logger) << "Failed to create scope proxy for " << scope_data_->id();
+    return;
+  }
+
+  LOG_DEBUG(logger) << "Created scope proxy for " << scope_data_->id();
+
+  scope_proxy_ = scope_proxy;
+
+  // shared properties
+  scope_data_->is_master = unity_protocol_scope_proxy_get_is_master(scope_proxy_);
+  scope_data_->search_hint = glib::gchar_to_string(unity_protocol_scope_proxy_get_search_hint(scope_proxy_));
+  // remote properties
+  search_in_global = unity_protocol_scope_proxy_get_search_in_global(scope_proxy_);
+  view_type = static_cast<ScopeViewType>(unity_protocol_scope_proxy_get_view_type(scope_proxy_));
+
+  connected_signal_.Connect(scope_proxy_, "notify::connected", sigc::mem_fun(this, &Impl::OnScopeConnectedChanged));
+  search_in_global_signal_.Connect(scope_proxy_, "notify::search-in-global", sigc::mem_fun(this, &Impl::OnScopeSearchInGlobalChanged));
+  is_master_signal_.Connect(scope_proxy_, "notify::is-master", sigc::mem_fun(this, &Impl::OnScopeIsMasterChanged));
+  search_hint_signal_.Connect(scope_proxy_, "notify::search-hint", sigc::mem_fun(this, &Impl::OnScopeSearchHintChanged));
+  view_type_signal_.Connect(scope_proxy_, "notify::view-type", sigc::mem_fun(this, &Impl::OnScopeViewTypeChanged));
+  filters_signal_.Connect(scope_proxy_, "notify::filters-model", sigc::mem_fun(this, &Impl::OnScopeFiltersChanged));
+  categories_signal_.Connect(scope_proxy_, "notify::categories-model", sigc::mem_fun(this, &Impl::OnScopeCategoriesChanged));
+  metadata_signal_.Connect(scope_proxy_, "notify::metadata", sigc::mem_fun(this, &Impl::OnScopeMetadataChanged));
+  optional_metadata_signal_.Connect(scope_proxy_, "notify::optional-metadata", sigc::mem_fun(this, &Impl::OnScopeOptionalMetadataChanged));
+  category_order_signal_.Connect(scope_proxy_, "category-order-changed", sigc::mem_fun(this, &Impl::OnScopeCategoryOrderChanged));
+
+  scope_proxy_connected_ = unity_protocol_scope_proxy_get_connected(scope_proxy_);
+  
+  if (scope_proxy_connected_)
+    OpenChannel();
+  else
+    LOG_WARN(logger) << "Proxy scope not connected for " << scope_data_->id();
+}
+
+void ScopeProxy::Impl::OpenChannel()
+{
+  if (channel != "")
+    return;
+
+  unity_protocol_scope_proxy_open_channel(scope_proxy_,
+                                          UNITY_PROTOCOL_CHANNEL_TYPE_DEFAULT,
+                                          UNITY_PROTOCOL_CHANNEL_FLAGS_NONE,
+                                          cancel_scope_,
+                                          OnScopeAsyncCallback,
+                                          new ScopeAyncReplyData(sigc::mem_fun(this, &Impl::OnChannelOpened)));
+}
+
+void ScopeProxy::Impl::OnChannelOpened(GObject *source_object, GAsyncResult *res)
+{
+  if (!UNITY_PROTOCOL_IS_SCOPE_PROXY(source_object))
+    return;
+
+  glib::Object<UnityProtocolScopeProxy> scope_proxy;
+  glib::Error error;
+  DeeSerializableModel* serialisable_model = nullptr;
+  glib::String tmp_channel(unity_protocol_scope_proxy_open_channel_finish(UNITY_PROTOCOL_SCOPE_PROXY(source_object), res, &serialisable_model, &error));
+
+  glib::Object<DeeModel> results_dee_model(DEE_MODEL(serialisable_model));
+  results_->SetModel(results_dee_model);
+
+  glib::Object<DeeModel> filters_dee_model(DEE_MODEL(unity_protocol_scope_proxy_get_filters_model(scope_proxy_)), glib::AddRef());
+  filters_->SetModel(filters_dee_model);
+  filters_change_connection.disconnect();
+  filters_change_connection = filters_->filter_changed.connect([this](Filter::Ptr const& filter)
+  {
+    glib::HintsMap hints;
+    hints["changed-filter-row"] = filter->VariantValue();
+    Search(last_search_, hints, nullptr, cancel_scope_);
+  });
+
+  glib::Object<DeeModel> categories_dee_model(DEE_MODEL(unity_protocol_scope_proxy_get_categories_model(scope_proxy_)), glib::AddRef());
+  categories_->SetModel(categories_dee_model);
+
+  if (tmp_channel.Str().empty() || error)
+  {
+    channel = "";
+    connected = false;
+
+    LOG_ERROR(logger) << "Failed to open channel for " << scope_data_->id();
+    return;
+  }
+
+  channel = tmp_channel.Str();
+  LOG_DEBUG(logger) << "Opened channel:" << channel() << " for " << scope_data_->id();
+  connected = true;
+
+  if (!searching_)
+  {
+    // If a search hasn't initiated this channel opening, perform the search to get the results.
+    Search(last_search_, glib::HintsMap(), nullptr, cancel_scope_);
+  }
+}
+
+void ScopeProxy::Impl::CloseChannel()
+{
+  if (channel != "")
+  {
+    unity_protocol_scope_proxy_close_channel(scope_proxy_,
+                                             channel.Get().c_str(),
+                                             nullptr,
+                                             OnCloseChannel,
+                                             nullptr);
+    channel = "";
+  }
+}
+
+void ScopeProxy::Impl::OnCloseChannel(GObject *source_object, GAsyncResult *res, gpointer user_data)
+{
+  glib::Error err;
+  unity_protocol_scope_proxy_close_channel_finish(UNITY_PROTOCOL_SCOPE_PROXY(source_object), res, &err);
+}
+
+void ScopeProxy::Impl::WaitForProxyConnection(GCancellable* cancellable,
+                                   int timeout_msec,
+                                   std::function<void(glib::Error const&)> const& callback)
+{
+  if (!connected)
+  {
+    auto con = std::make_shared<sigc::connection>();
+    auto canc = glib::Object<GCancellable>(cancellable, glib::AddRef());
+
+    // add a timeout
+    auto timeout = std::make_shared<glib::Timeout>(timeout_msec < 0 ? 30000 : timeout_msec, [con, canc, callback] ()
+    {
+      if (!g_cancellable_is_cancelled(canc))
+      {
+        glib::Error err;
+        GError** real_err = &err;
+        *real_err = g_error_new_literal(G_DBUS_ERROR, G_DBUS_ERROR_TIMED_OUT,
+                                        "Timed out waiting for scope proxy connection");
+        callback(err);
+      }
+      con->disconnect();
+      return false;
+    });
+    // wait for the signal
+    *con = connected.changed.connect([con, canc, timeout, callback] (bool connected)
+    {
+      if (!connected)
+        return;
+
+      if (!g_cancellable_is_cancelled(canc)) callback(glib::Error());
+      timeout->Remove();
+      con->disconnect();
+    });
+  }
+  else
+  {
+    callback(glib::Error());
+  }
+}
+
+void ScopeProxy::Impl::Search(std::string const& search_string, glib::HintsMap const& hints, SearchCallback const& callback, GCancellable* cancellable)
+{
+  // Activate a guard against performing a "on channel open search" if we're not connected.
+  utils::AutoResettingVariable<bool> searching(&searching_, true);
+
+  GCancellable* target_canc = cancellable != NULL ? cancellable : cancel_scope_;
+
+  if (!scope_proxy_)
+  {
+    if (!proxy_created_)
+      CreateProxy();
+
+    glib::Object<GCancellable> canc(target_canc, glib::AddRef());
+    WaitForProxyConnection(canc, PROXY_CONNECT_TIMEOUT, [this, search_string, hints, callback, canc] (glib::Error const& err)
+    {
+      if (err)
+      {
+        callback(glib::HintsMap(), err);
+        LOG_WARNING(logger) << "Could not search '" << search_string
+                            << "' on " << scope_data_->id() << " => " << err;
+      }
+      else
+      {
+        Search(search_string, hints, callback, canc);
+      }
+    });
+    return;
+  }
+
+  SearchData* data = new SearchData();
+  data->callback = callback;
+
+  GHashTable* hints_table = glib::hashtable_from_hintsmap(hints);
+
+  last_search_ = search_string.c_str();
+  unity_protocol_scope_proxy_search(scope_proxy_,
+    channel().c_str(),
+    search_string.c_str(),
+    hints_table,
+    target_canc,
+    Impl::OnScopeSearchCallback,
+    data);
+
+  g_hash_table_unref(hints_table);
+}
+
+void ScopeProxy::Impl::Activate(std::string const& uri, uint activate_type, glib::HintsMap const& hints, ScopeProxy::ActivateCallback const& callback, GCancellable* cancellable)
+{
+  GCancellable* target_canc = cancellable != NULL ? cancellable : cancel_scope_;
+
+  if (!scope_proxy_)
+  {
+    if (!proxy_created_)
+      CreateProxy();
+
+    glib::Object<GCancellable> canc(target_canc, glib::AddRef());
+    WaitForProxyConnection(canc, PROXY_CONNECT_TIMEOUT, [this, uri, activate_type, hints, callback, canc] (glib::Error const& err)
+    {
+      if (err)
+      {
+        callback(uri, ScopeHandledType::NOT_HANDLED, glib::HintsMap(), err);
+        LOG_WARNING(logger) << "Could not activate '" << uri
+                            << "' on " << scope_data_->id() << " => " << err;
+      }
+      else
+      {
+        Activate(uri, activate_type, hints, callback, canc);
+      }
+    });
+    return;
+  }
+
+  ActivateData* data = new ActivateData();
+  data->callback = callback;
+
+  GHashTable* hints_table = glib::hashtable_from_hintsmap(hints);
+
+  unity_protocol_scope_proxy_activate(scope_proxy_,
+                                      channel().c_str(),
+                                      uri.c_str(),
+                                      (UnityProtocolActionType)activate_type,
+                                      hints_table,
+                                      target_canc,
+                                      Impl::OnScopeActivateCallback,
+                                      data);
+  g_hash_table_unref(hints_table);
+}
+
+void ScopeProxy::Impl::UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, ScopeProxy::UpdatePreviewPropertyCallback const& callback, GCancellable* cancellable)
+{
+  GCancellable* target_canc = cancellable != NULL ? cancellable : cancel_scope_;
+
+  if (!scope_proxy_)
+  {
+    if (!proxy_created_)
+      CreateProxy();
+
+    glib::Object<GCancellable> canc(target_canc, glib::AddRef());
+    WaitForProxyConnection(canc, PROXY_CONNECT_TIMEOUT, [this, uri, hints, callback, canc] (glib::Error const& err)
+    {
+      if (err)
+      {
+        callback(glib::HintsMap(), err);
+        LOG_WARNING(logger) << "Could not update preview property '" << uri
+                            << "' on " << scope_data_->id() << " => " << err;
+      }
+      else
+      {
+        UpdatePreviewProperty(uri, hints, callback, canc);
+      }
+    });
+    return;
+  }
+
+  UpdatePreviewPropertyData* data = new UpdatePreviewPropertyData();
+  data->callback = callback;
+
+  GHashTable* hints_table = glib::hashtable_from_hintsmap(hints);
+
+  unity_protocol_scope_proxy_update_preview_property(scope_proxy_,
+                                                     channel().c_str(),
+                                                     uri.c_str(),
+                                                     hints_table,
+                                                     target_canc,
+                                                     Impl::OnScopeUpdatePreviewPropertyCallback,
+                                                     data);
+
+  g_hash_table_unref(hints_table);
+}
+
+void ScopeProxy::Impl::OnScopeConnectedChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  bool tmp_scope_proxy_connected = unity_protocol_scope_proxy_get_connected(scope_proxy_);  
+  if (tmp_scope_proxy_connected != scope_proxy_connected_)
+  {
+    scope_proxy_connected_ = tmp_scope_proxy_connected;
+
+    LOG_WARN(logger) << "Connection state changed for " << scope_data_->id() << " => " << (scope_proxy_connected_ ? "connected" : "disconnected");
+
+    CloseChannel();
+    if (tmp_scope_proxy_connected)
+    {
+      OpenChannel();
+    }
+  }
+}
+
+void ScopeProxy::Impl::OnScopeIsMasterChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  scope_data_->is_master = unity_protocol_scope_proxy_get_is_master(proxy);
+}
+
+void ScopeProxy::Impl::OnScopeSearchInGlobalChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  search_in_global = unity_protocol_scope_proxy_get_search_in_global(proxy);
+}
+
+void ScopeProxy::Impl::OnScopeSearchHintChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  scope_data_->search_hint = unity_protocol_scope_proxy_get_search_hint(proxy);
+}
+
+void ScopeProxy::Impl::OnScopeViewTypeChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  view_type = static_cast<ScopeViewType>(unity_protocol_scope_proxy_get_view_type(proxy));
+}
+
+void ScopeProxy::Impl::OnScopeFiltersChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  LOG_DEBUG(logger) << scope_data_->id() << " - Filter changed by server";
+  bool blocked = filters_change_connection.block(true);
+
+  glib::Object<DeeModel> filters_dee_model(DEE_MODEL(unity_protocol_scope_proxy_get_filters_model(scope_proxy_)), glib::AddRef());
+  categories_->SetModel(filters_dee_model);
+
+  filters_change_connection.block(blocked);
+
+  owner_->filters.EmitChanged(filters());
+}
+
+void ScopeProxy::Impl::OnScopeCategoriesChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+  glib::Object<DeeModel> categories_dee_model(DEE_MODEL(unity_protocol_scope_proxy_get_categories_model(scope_proxy_)), glib::AddRef());
+  categories_->SetModel(categories_dee_model);
+
+  owner_->categories.EmitChanged(categories());
+}
+
+void ScopeProxy::Impl::OnScopeMetadataChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+}
+
+void ScopeProxy::Impl::OnScopeOptionalMetadataChanged(UnityProtocolScopeProxy* proxy, GParamSpec* param)
+{
+}
+
+void ScopeProxy::Impl::OnScopeCategoryOrderChanged(UnityProtocolScopeProxy* sender, const gchar* channel_id, guint32* new_order, int new_order_length1)
+{
+  if (channel() != glib::gchar_to_string(channel_id))
+    return;
+
+  std::vector<int> order;
+  for (int i = 0; i < new_order_length1; i++)
+  {
+    order.push_back(new_order[i]);
+  }
+
+  category_order = order;
+}
+
+static void category_filter_map_func (DeeModel* orig_model,
+                                      DeeFilterModel* filter_model,
+                                      gpointer user_data)
+{
+  DeeModelIter* iter;
+  DeeModelIter* end;
+  unsigned index = GPOINTER_TO_UINT(user_data);
+
+  iter = dee_model_get_first_iter(orig_model);
+  end = dee_model_get_last_iter(orig_model);
+  while (iter != end)
+  {
+    unsigned category_index = dee_model_get_uint32(orig_model, iter,
+                                                   CATEGORY_COLUMN);
+    if (index == category_index)
+    {
+      dee_filter_model_append_iter(filter_model, iter);
+    }
+    iter = dee_model_next(orig_model, iter);
+  }
+}
+
+static gboolean category_filter_notify_func (DeeModel* orig_model,
+                                             DeeModelIter* orig_iter,
+                                             DeeFilterModel* filter_model,
+                                             gpointer user_data)
+{
+  unsigned index = GPOINTER_TO_UINT(user_data);
+  unsigned category_index = dee_model_get_uint32(orig_model, orig_iter,
+                                                 CATEGORY_COLUMN);
+
+  if (index != category_index)
+    return FALSE;
+
+  dee_filter_model_insert_iter_with_original_order(filter_model, orig_iter);
+  return TRUE;
+}
+
+DeeFilter* ScopeProxy::Impl::GetFilterForCategory(unsigned category, DeeFilter* filter) const
+{
+  filter->map_func = category_filter_map_func;
+  filter->map_notify = category_filter_notify_func;
+  filter->destroy = nullptr;
+  filter->userdata = GUINT_TO_POINTER(category);
+
+  return filter;
+}
+
+ScopeProxy::ScopeProxy(ScopeData::Ptr const& scope_data)
+: pimpl(new Impl(this, scope_data))
+{
+}
+
+
+ScopeProxy::ScopeProxy(std::string const& dbus_name, std::string const& dbus_path)
+: pimpl(new Impl(this, Impl::CreateData(dbus_name, dbus_path)))
+{
+}
+
+ScopeProxy::~ScopeProxy()
+{  
+}
+
+void ScopeProxy::CreateProxy()
+{
+  pimpl->CreateProxy();
+}
+
+void ScopeProxy::Search(std::string const& search_string, SearchCallback const& callback, GCancellable* cancellable)
+{
+  pimpl->Search(search_string, glib::HintsMap(), callback, cancellable);
+}
+
+void ScopeProxy::Activate(std::string const& uri, uint activate_type, glib::HintsMap const& hints, ScopeProxy::ActivateCallback const& callback, GCancellable* cancellable)
+{
+  pimpl->Activate(uri, activate_type, hints, callback, cancellable);
+}
+
+void ScopeProxy::UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, ScopeProxy::UpdatePreviewPropertyCallback const& callback, GCancellable* cancellable)
+{
+  pimpl->UpdatePreviewProperty(uri, hints, callback, cancellable);
+}
+
+Results::Ptr ScopeProxy::GetResultsForCategory(unsigned category) const
+{
+  Results::Ptr all_results = results;
+
+  if (!all_results || !all_results->model())
+    return Results::Ptr();
+
+  DeeFilter filter;
+  pimpl->GetFilterForCategory(category, &filter);
+  glib::Object<DeeModel> filter_model(dee_filter_model_new(all_results->model(), &filter));
+
+  auto func = [all_results](glib::Object<DeeModel> const& model) { return all_results->GetTag(); };
+  
+  Results::Ptr results_category_model(new Results(ModelType::UNATTACHED));
+  results_category_model->SetModel(filter_model, func);
+  return results_category_model;
+}
+
+
+} // namespace dash
+} // namespace unity
 
=== added file 'UnityCore/ScopeProxy.h'
--- UnityCore/ScopeProxy.h	1970-01-01 00:00:00 +0000
+++ UnityCore/ScopeProxy.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,57 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef UNITY_SCOPE_PROXY_H
+#define UNITY_SCOPE_PROXY_H
+
+#include "ScopeProxyInterface.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class ScopeProxy : public ScopeProxyInterface
+{
+public:
+  ScopeProxy(ScopeData::Ptr const& scope_data);
+  ~ScopeProxy();
+
+  virtual void CreateProxy();
+
+  virtual void Search(std::string const& search_hint, SearchCallback const& callback, GCancellable* cancellable);
+
+  virtual void Activate(std::string const& uri, uint activate_type, glib::HintsMap const& hints, ActivateCallback const& callback, GCancellable* cancellable);
+
+  virtual void UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, UpdatePreviewPropertyCallback const& callback, GCancellable* cancellable);
+
+  Results::Ptr GetResultsForCategory(unsigned category) const;
+
+protected:
+  ScopeProxy(std::string const& dbus_name, std::string const& dbus_path);
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // UNITY_SCOPE_PROXY_H
 
=== added file 'UnityCore/ScopeProxyInterface.h'
--- UnityCore/ScopeProxyInterface.h	1970-01-01 00:00:00 +0000
+++ UnityCore/ScopeProxyInterface.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,96 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef UNITY_SCOPE_PROXY_INTERFACE_H
+#define UNITY_SCOPE_PROXY_INTERFACE_H
+
+#include "GLibWrapper.h"
+#include <NuxCore/Property.h>
+#include <dee.h>
+
+#include "Results.h"
+#include "Filters.h"
+#include "Categories.h"
+#include "GLibWrapper.h"
+#include "ScopeData.h"
+
+namespace unity
+{
+namespace dash
+{
+
+enum ScopeHandledType
+{
+  NOT_HANDLED=0,
+  SHOW_DASH,
+  HIDE_DASH,
+  GOTO_DASH_URI,
+  SHOW_PREVIEW
+};
+
+class ScopeProxyInterface : public sigc::trackable, boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<ScopeProxyInterface> Ptr;
+
+  virtual ~ScopeProxyInterface() {}
+
+  nux::ROProperty<std::string> dbus_name;
+  nux::ROProperty<std::string> dbus_path;
+  nux::ROProperty<bool> connected;
+  nux::ROProperty<std::string> channel;
+
+  nux::ROProperty<bool> visible;
+  nux::ROProperty<bool> is_master;
+  nux::ROProperty<bool> search_in_global;
+  nux::ROProperty<std::string> search_hint;
+  nux::RWProperty<ScopeViewType> view_type;
+
+  nux::ROProperty<Results::Ptr> results;
+  nux::ROProperty<Filters::Ptr> filters;
+  nux::ROProperty<Categories::Ptr> categories;
+  nux::ROProperty<std::vector<int>> category_order;
+
+  nux::ROProperty<std::string> name;
+  nux::ROProperty<std::string> description;
+  nux::ROProperty<std::string> icon_hint;
+  nux::ROProperty<std::string> category_icon_hint;
+  nux::ROProperty<std::vector<std::string>> keywords;
+  nux::ROProperty<std::string> type;
+  nux::ROProperty<std::string> query_pattern;
+  nux::ROProperty<std::string> shortcut;
+
+  virtual void CreateProxy() {}
+
+  typedef std::function<void(glib::HintsMap const&, glib::Error const&)> SearchCallback;
+  virtual void Search(std::string const& search_hint, SearchCallback const& callback, GCancellable* cancellable) = 0;
+
+  typedef std::function<void(std::string const&, ScopeHandledType, glib::HintsMap const&, glib::Error const&)> ActivateCallback;
+  virtual void Activate(std::string const& uri, uint activate_type, glib::HintsMap const& hints, ActivateCallback const& callback, GCancellable* cancellable) = 0;
+
+  typedef std::function<void(glib::HintsMap const&, glib::Error const&)> UpdatePreviewPropertyCallback;
+  virtual void UpdatePreviewProperty(std::string const& uri, glib::HintsMap const& hints, UpdatePreviewPropertyCallback const& callback, GCancellable* cancellable) = 0;
+
+  virtual Results::Ptr GetResultsForCategory(unsigned category) const = 0;
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // UNITY_SCOPE_PROXY_INTERFACE_H
 \ No newline at end of file
 
=== added file 'UnityCore/Scopes.cpp'
--- UnityCore/Scopes.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/Scopes.cpp	2013-02-21 10:37:29 +0000
@@ -0,0 +1,271 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include "Scopes.h"
+#include <stdexcept>
+
+namespace unity
+{
+namespace dash
+{
+DECLARE_LOGGER(logger, "unity.dash.scopes");
+
+class Scopes::Impl
+{
+public:
+  Impl(Scopes* owner, ScopesReader::Ptr scopes_reader);
+  ~Impl();
+
+  void LoadScopes();
+  void InsertScope(ScopeData::Ptr const& data, unsigned index);
+  void RemoveScope(std::string const& scope);
+
+  ScopeList const& GetScopes() const;
+  Scope::Ptr GetScope(std::string const& scope_id, int* index = nullptr) const;
+  Scope::Ptr GetScopeAtIndex(std::size_t index) const;
+  Scope::Ptr GetScopeForShortcut(std::string const& scope_shortcut) const;
+
+  Scopes* owner_;
+  ScopesReader::Ptr scopes_reader_;
+  ScopeList scopes_;
+  sigc::connection scope_changed_signal;
+
+  std::size_t get_count() const { return scopes_.size(); }
+
+  void UpdateScopes(ScopeDataList const& scopes_list);
+};
+
+Scopes::Impl::Impl(Scopes* owner, ScopesReader::Ptr scopes_reader)
+: owner_(owner)
+, scopes_reader_(scopes_reader)
+{
+}
+
+Scopes::Impl::~Impl()
+{
+  scope_changed_signal.disconnect();
+}
+
+void Scopes::Impl::UpdateScopes(ScopeDataList const& scopes_list)
+{
+  // insert new.
+  int index = 0;
+  for (ScopeData::Ptr const& scope_data: scopes_list)  
+  {
+    InsertScope(scope_data, index++);
+  }
+
+  // remove old.
+  std::vector<std::string> remove_scopes;
+  for (Scope::Ptr const& scope: scopes_)
+  {
+    auto scope_data_position = std::find_if(scopes_list.begin(),
+                                            scopes_list.end(),
+                                            [scope](ScopeData::Ptr const& data) { return data->id() == scope->id(); });
+    if (scope_data_position == scopes_list.end())
+    {
+      remove_scopes.push_back(scope->id());
+    }
+  }
+  for (std::string const& scope: remove_scopes)
+  {
+    RemoveScope(scope);
+  }
+}
+
+void Scopes::Impl::LoadScopes()
+{
+  if (!scopes_reader_)
+    return;
+
+  scope_changed_signal.disconnect();
+  scope_changed_signal = scopes_reader_->scopes_changed.connect(sigc::mem_fun(this, &Impl::UpdateScopes));
+  UpdateScopes(scopes_reader_->GetScopesData());
+}
+
+void Scopes::Impl::InsertScope(ScopeData::Ptr const& scope_data, unsigned index)
+{
+  if (!scope_data)
+    return;
+
+  index = std::min(index, static_cast<unsigned>(scopes_.size()));
+
+  auto start = scopes_.begin();
+  auto scope_position = std::find_if(scopes_.begin(),
+                                     scopes_.end(),
+                                     [scope_data](Scope::Ptr const& value) { return value->id() == scope_data->id(); });
+  if (scope_position == scopes_.end())
+  {
+    Scope::Ptr scope(owner_->CreateScope(scope_data));
+    if (scope)
+    {
+      scopes_.insert(start+index, scope);
+
+      owner_->scope_added.emit(scope, index);
+    }
+  }
+  else
+  {
+    Scope::Ptr scope = *scope_position;
+    if (scope_position > (start + index))
+    {
+      scopes_.erase(scope_position);
+      scopes_.insert(start + index, scope);
+
+      owner_->scopes_reordered.emit(GetScopes());
+    }
+    else if (index > 0 && scope_position < (start + index - 1))
+    {
+      scopes_.erase(scope_position);
+
+      scopes_.insert(start + index - 1, scope);
+
+      owner_->scopes_reordered.emit(GetScopes());
+    }
+  }
+}
+
+void Scopes::Impl::RemoveScope(std::string const& scope_id)
+{
+  auto scope_position = std::find_if(scopes_.begin(),
+                                     scopes_.end(),
+                                     [scope_id](Scope::Ptr const& value) { return value->id() == scope_id; });
+
+  if (scope_position != scopes_.end())
+  {
+    Scope::Ptr scope = *scope_position;
+    scopes_.erase(scope_position);
+
+    owner_->scope_removed.emit(scope);
+  }
+}
+
+Scopes::ScopeList const& Scopes::Impl::GetScopes() const
+{
+  return scopes_;
+}
+
+Scope::Ptr Scopes::Impl::GetScope(std::string const& scope_id, int* index) const
+{
+  int tmp_index = 0;
+  for (auto scope: scopes_)
+  {
+    if (scope->id == scope_id)
+    {
+      if (index)
+        *index = tmp_index;
+      return scope;
+    }
+    tmp_index++;
+  }
+  if (index)
+    *index = -1;
+  return Scope::Ptr();
+}
+
+Scope::Ptr Scopes::Impl::GetScopeAtIndex(std::size_t index) const
+{
+  try
+  {
+    return scopes_.at(index);
+  }
+  catch (std::out_of_range& error)
+  {
+    LOG_WARN(logger) << error.what();
+  }
+  return Scope::Ptr();
+}
+
+Scope::Ptr Scopes::Impl::GetScopeForShortcut(std::string const& scope_shortcut) const
+{
+  for (auto scope: scopes_)
+  {
+    if (scope->shortcut == scope_shortcut)
+    {
+      return scope;
+    }
+  }
+
+  return Scope::Ptr();
+}
+
+Scopes::Scopes(ScopesReader::Ptr scopes_reader)
+: pimpl(new Impl(this, scopes_reader))
+{
+  count.SetGetterFunction(sigc::mem_fun(pimpl.get(), &Impl::get_count));
+}
+
+Scopes::~Scopes()
+{
+}
+
+void Scopes::LoadScopes()
+{
+  pimpl->LoadScopes();
+}
+
+Scopes::ScopeList const& Scopes::GetScopes() const
+{
+  return pimpl->GetScopes();
+}
+
+Scope::Ptr Scopes::GetScope(std::string const& scope_id, int* position) const
+{
+  return pimpl->GetScope(scope_id, position);
+}
+
+Scope::Ptr Scopes::GetScopeAtIndex(std::size_t index) const
+{
+  return pimpl->GetScopeAtIndex(index);
+}
+
+Scope::Ptr Scopes::GetScopeForShortcut(std::string const& scope_shortcut) const
+{
+  return pimpl->GetScopeForShortcut(scope_shortcut);
+}
+
+void Scopes::InsertScope(std::string const& scope_id, unsigned index)
+{
+  if (!pimpl->scopes_reader_)
+    return;
+
+  ScopeData::Ptr scope_data(pimpl->scopes_reader_->GetScopeDataById(scope_id));
+  if (scope_data)
+    pimpl->InsertScope(scope_data, index);
+}
+
+void Scopes::RemoveScope(std::string const& scope_id)
+{
+  pimpl->RemoveScope(scope_id);
+}
+
+Scope::Ptr Scopes::CreateScope(ScopeData::Ptr const& scope_data)
+{
+  if (!scope_data)
+    return Scope::Ptr();
+
+  LOG_DEBUG(logger) << "Creating scope: " << scope_data->id() << " (" << scope_data->dbus_path()  << " @ " << scope_data->dbus_name() << ")";
+  Scope::Ptr scope(new Scope(scope_data));
+  scope->Init();
+  return scope;
+}
+
+
+} // namespace dash
+} // namespace unity
 
=== added file 'UnityCore/Scopes.h'
--- UnityCore/Scopes.h	1970-01-01 00:00:00 +0000
+++ UnityCore/Scopes.h	2013-02-21 10:37:29 +0000
@@ -0,0 +1,94 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+                Nick Dedekind <[e-mail]>
+ */
+
+#ifndef UNITY_SCOPES_H
+#define UNITY_SCOPES_H
+
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+
+#include "Scope.h"
+
+namespace unity
+{
+namespace dash
+{
+
+typedef std::vector<ScopeData::Ptr> ScopeDataList;
+
+class ScopesReader : public sigc::trackable, boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<ScopesReader> Ptr;
+  virtual ~ScopesReader() {}
+
+  virtual void LoadScopes() = 0;
+  virtual ScopeDataList const& GetScopesData() const = 0;
+
+  virtual ScopeData::Ptr GetScopeDataById(std::string const& scope_id) const = 0;
+
+  sigc::signal<void, ScopeDataList const&> scopes_changed;
+};
+
+class Scopes : public sigc::trackable, boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<Scopes> Ptr;
+  typedef std::vector<Scope::Ptr> ScopeList;
+ 
+  Scopes(ScopesReader::Ptr scope_reader);
+  virtual ~Scopes();
+
+  virtual void LoadScopes();
+
+  /**
+   * Get the currently loaded Scopess. This is necessary as some of the consumers
+   * of this object employ a lazy-loading technique to reduce the overhead of
+   * starting Unity. Therefore, the Scopes may already have been loaded by the time
+   * the objects have been initiated (and so just connecting to the signals is not
+   * enough)
+   */
+  virtual ScopeList const& GetScopes() const;
+  virtual Scope::Ptr GetScope(std::string const& scope_id, int* position = nullptr) const;
+  virtual Scope::Ptr GetScopeAtIndex(std::size_t index) const;
+  virtual Scope::Ptr GetScopeForShortcut(std::string const& scope_shortcut) const;
+
+  nux::ROProperty<std::size_t> count;
+
+  sigc::signal<void, Scope::Ptr const&, int> scope_added;
+  sigc::signal<void, Scope::Ptr const&> scope_removed;
+
+  sigc::signal<void, ScopeList const&> scopes_reordered;
+
+protected:
+  virtual void InsertScope(std::string const& scope_id, unsigned index);
+  virtual void RemoveScope(std::string const& scope_id);
+
+  virtual Scope::Ptr CreateScope(ScopeData::Ptr const& scope_data);
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // UNITY_SCOPES_H
 
=== modified file 'UnityCore/SeriesPreview.cpp'
--- UnityCore/SeriesPreview.cpp	2012-07-12 16:36:54 +0000
+++ UnityCore/SeriesPreview.cpp	2013-02-21 10:37:29 +0000
@@ -33,14 +33,14 @@
   Impl(SeriesPreview* owner, glib::Object<GObject> const& proto_obj);
 
   void SetupGetters();
-  void selected_item_reply(GVariant* reply);
+  void selected_item_reply(glib::HintsMap const&, glib::Error const&);
   int get_selected_item_index() const { return selected_item_index_; };
   bool set_selected_item_index(int index);
   SeriesItemPtrList get_items() const { return items_list_; };
   Preview::Ptr get_child_preview() const
   {
-    if (!child_preview_->parent_lens)
-      child_preview_->parent_lens = owner_->parent_lens();
+    if (!child_preview_->parent_scope)
+      child_preview_->parent_scope = owner_->parent_scope();
     if (child_preview_->preview_uri().empty())
       child_preview_->preview_uri = owner_->preview_uri();
     return child_preview_;
@@ -101,24 +101,24 @@
     unity_protocol_series_preview_set_selected_item(raw_preview_, index);
     glib::Variant properties(unity_protocol_preview_end_updates(preview),
                              glib::StealRef());
-    owner_->Update(properties, sigc::mem_fun(this, &SeriesPreview::Impl::selected_item_reply));
-    return true;
+
+  glib::HintsMap property_hints;
+  if (properties.ASVToHints(property_hints))
+    owner_->Update(property_hints, sigc::mem_fun(this, &SeriesPreview::Impl::selected_item_reply));
+  else
+    g_assert(false);
   }
 
   return false;
 }
 
-void SeriesPreview::Impl::selected_item_reply(GVariant *reply)
+void SeriesPreview::Impl::selected_item_reply(glib::HintsMap const& hints, glib::Error const&)
 {
-  glib::Variant dict(reply);
-  glib::HintsMap hints;
-  dict.ASVToHints(hints);
-
   auto iter = hints.find("preview");
   if (iter != hints.end())
   {
     Preview::Ptr new_child = Preview::PreviewForVariant(iter->second);
-    new_child->parent_lens = owner_->parent_lens();
+    new_child->parent_scope = owner_->parent_scope();
     new_child->preview_uri = owner_->preview_uri(); // FIXME: really?
     child_preview_ = new_child;
     owner_->child_preview_changed.emit(new_child);
 
=== modified file 'UnityCore/Tracks.cpp'
--- UnityCore/Tracks.cpp	2012-06-19 16:47:56 +0000
+++ UnityCore/Tracks.cpp	2013-02-21 10:37:29 +0000
@@ -25,6 +25,7 @@
 {
 
 Tracks::Tracks()
+: Model<Track>::Model(ModelType::REMOTE_SHARED)
 {
   row_added.connect(sigc::mem_fun(this, &Tracks::OnRowAdded));
   row_changed.connect(sigc::mem_fun(this, &Tracks::OnRowChanged));
@@ -32,7 +33,7 @@
 }
 
 Tracks::Tracks(ModelType model_type)
-  : Model<Track>::Model(model_type)
+: Model<Track>::Model(model_type)
 {
   row_added.connect(sigc::mem_fun(this, &Tracks::OnRowAdded));
   row_changed.connect(sigc::mem_fun(this, &Tracks::OnRowChanged));
 
=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2012-11-06 18:19:09 +0000
+++ UnityCore/Variant.cpp	2013-02-21 10:37:29 +0000
@@ -125,6 +125,47 @@
   return bool(variant_);
 }
 
+static void g_variant_unref0 (gpointer var)
+{
+  if (var)
+    g_variant_unref((GVariant*)var);
+}
+
+GHashTable* hashtable_from_hintsmap(glib::HintsMap const& hints)
+{
+  GHashTable* hash_table = g_hash_table_new_full(g_str_hash, g_direct_equal, g_free, g_variant_unref0);
+
+  if (!hash_table)
+    return nullptr;
+
+  for (glib::HintsMap::const_iterator it = hints.begin(); it != hints.end(); ++it)
+  {
+    gchar* key = g_strdup(it->first.c_str());
+    GVariant* ptr = g_variant_ref(it->second);
+
+    g_hash_table_insert(hash_table, key, ptr);
+  }
+  return hash_table;
+}
+
+HintsMap const& hintsmap_from_hashtable(GHashTable* hashtable, HintsMap& hints)
+{
+  if (!hashtable)
+    return hints;
+
+  GHashTableIter hints_iter;
+  gpointer key, value;
+  g_hash_table_iter_init (&hints_iter, hashtable);
+  while (g_hash_table_iter_next (&hints_iter, &key, &value))
+  {
+    std::string hint_key(static_cast<gchar*>(key));
+    glib::Variant hint_value(static_cast<GVariant*>(value));
+
+    hints[hint_key] = hint_value;
+  }
+  return hints;
+}
+
 } // namespace glib
 
 namespace variant
@@ -220,6 +261,5 @@
   return *this;
 }
 
-
 }
 }
 
=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2012-11-06 18:19:09 +0000
+++ UnityCore/Variant.h	2013-02-21 10:37:29 +0000
@@ -33,6 +33,8 @@
 
 class Variant;
 typedef std::map<std::string, Variant> HintsMap;
+GHashTable* hashtable_from_hintsmap(HintsMap const& hints);
+HintsMap const& hintsmap_from_hashtable(GHashTable* hashtable, HintsMap& hints);
 
 struct StealRef {};
 
 
=== modified file 'com.canonical.Unity.gschema.xml'
--- com.canonical.Unity.gschema.xml	2013-02-06 11:07:00 +0000
+++ com.canonical.Unity.gschema.xml	2013-02-21 10:37:29 +0000
@@ -67,5 +67,15 @@
       <summary>List of lens ids specifying how lenses should be ordered in the Dash home screen.</summary>
       <description>The categories listed on the Dash home screen will be ordered according to this list. Lenses not appearing in this list will not have any particular ordering and will always sort after lenses specified in this list.</description>
     </key>
+    <key type="as" name="scopes">
+      <default>[ 'home.scope' , 'applications.scope' ]</default>
+      <summary>List of scope ids specifying which scopes should be created and the order to display them in.</summary>
+      <description>The scopes listed in the scope bar will be ordered according to this list.</description>
+    </key>
+    <key type="as" name="always-search">
+      <default>[ 'applications.lens' ]</default>
+      <summary>List of scope ids which are always searched when the search string changes.</summary>
+      <description></description>
+    </key>
   </schema>
 </schemalist>
 
=== modified file 'dash/DashController.cpp'
--- dash/DashController.cpp	2013-01-30 02:11:19 +0000
+++ dash/DashController.cpp	2013-02-21 10:37:29 +0000
@@ -403,14 +403,14 @@
 gboolean Controller::CheckShortcutActivation(const char* key_string)
 {
   EnsureDash();
-  std::string lens_id = view_->GetIdForShortcutActivation(std::string(key_string));
-  if (lens_id != "")
+  std::string scope_id = view_->GetIdForShortcutActivation(std::string(key_string));
+  if (scope_id != "")
   {
     WindowManager& wm = WindowManager::Default();
     if (wm.IsScaleActive())
       wm.TerminateScale();
 
-    GVariant* args = g_variant_new("(sus)", lens_id.c_str(), dash::GOTO_DASH_URI, "");
+    GVariant* args = g_variant_new("(sus)", scope_id.c_str(), dash::GOTO_DASH_URI, "");
     OnActivateRequest(args);
     g_variant_unref(args);
     return true;
 
=== modified file 'dash/DashView.cpp'
--- dash/DashView.cpp	2013-02-14 22:12:50 +0000
+++ dash/DashView.cpp	2013-02-21 10:37:29 +0000
@@ -31,6 +31,7 @@
 #include <NuxCore/Logger.h>
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/RadioOptionFilter.h>
+#include <UnityCore/GSettingsScopes.h>
 
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/KeyboardUtil.h"
@@ -110,9 +111,8 @@
 
 NUX_IMPLEMENT_OBJECT_TYPE(DashView);
 
-DashView::DashView()
+DashView::DashView(ScopesCreator scopes_creator)
   : nux::View(NUX_TRACKER_LOCATION)
-  , home_lens_(new HomeLens(_("Home"), _("Home screen"), _("Search your computer and online sources")))
   , preview_container_(nullptr)
   , preview_displaying_(false)
   , preview_navigation_mode_(previews::Navigation::NONE)
@@ -137,32 +137,34 @@
   SetupViews();
   SetupUBusConnections();
 
-  lenses_.lens_added.connect(sigc::mem_fun(this, &DashView::OnLensAdded));
   mouse_down.connect(sigc::mem_fun(this, &DashView::OnMouseButtonDown));
   preview_state_machine_.PreviewActivated.connect(sigc::mem_fun(this, &DashView::BuildPreview));
   Relayout();
 
-  home_lens_->AddLenses(lenses_);
-  lens_bar_->Activate("home.lens");
-
-  // we will special case when applications lens finishes global search
-  // because we want to be able to launch applications immediately
-  // without waiting for the search finished signal which will
-  // be delayed by all the lenses we're searching
-  home_lens_->lens_search_finished.connect(sigc::mem_fun(this, &DashView::OnAppsGlobalSearchFinished));
-
   // We are interested in the color of the desktop background.
   ubus_manager_.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, sigc::mem_fun(this, &DashView::OnBGColorChanged));
 
   // request the latest colour from bghash
   ubus_manager_.SendMessage(UBUS_BACKGROUND_REQUEST_COLOUR_EMIT);
 
+  if (scopes_creator == nullptr)
+  {
+    scopes_creator = [this]() { scopes_.reset(new GSettingsScopes()); };
+  }
+
+  scopes_creator();
+  if (scopes_)
+  {
+    scopes_->scope_added.connect(sigc::mem_fun(this, &DashView::OnScopeAdded));
+    scopes_->LoadScopes();
+  }
 }
 
 DashView::~DashView()
 {
+  scope_can_refine_connection_.disconnect();
   // Do this explicitely, otherwise dee will complain about invalid access
-  // to the lens models
+  // to the scope models
   RemoveLayout();
 }
 
@@ -220,12 +222,12 @@
     StartPreviewAnimation();
 
     content_view_->SetPresentRedirectedView(false);
-    preview_lens_view_ = active_lens_view_;
-    if (preview_lens_view_)
+    preview_scope_view_ = active_scope_view_;
+    if (preview_scope_view_)
     {
-      preview_lens_view_->ForceCategoryExpansion(stored_activated_unique_id_, true);
-      preview_lens_view_->EnableResultTextures(true);
-      preview_lens_view_->PushFilterExpansion(false);
+      preview_scope_view_->ForceCategoryExpansion(stored_activated_unique_id_, true);
+      preview_scope_view_->EnableResultTextures(true);
+      preview_scope_view_->PushFilterExpansion(false);
     }
 
     if (!preview_container_)
@@ -237,7 +239,7 @@
     }
     preview_container_->Preview(model, previews::Navigation::NONE); // no swipe left or right
 
-    preview_container_->SetGeometry(lenses_layout_->GetGeometry());
+    preview_container_->SetGeometry(scopes_layout_->GetGeometry());
     preview_displaying_ = true;
 
     // connect to nav left/right signals to request nav left/right movement.
@@ -354,8 +356,8 @@
       preview_container_animation_->Start();
     }
 
-    if (preview_lens_view_)
-      preview_lens_view_->SetResultsPreviewAnimationValue(animate_split_value_);
+    if (preview_scope_view_)
+      preview_scope_view_->SetResultsPreviewAnimationValue(animate_split_value_);
   });
 
   split_animation_->finished.connect(sigc::mem_fun(this, &DashView::OnPreviewAnimationFinished));
@@ -415,8 +417,8 @@
           split_animation_->finished.connect(sigc::mem_fun(this, &DashView::OnPreviewAnimationFinished));
           split_animation_->Start();
 
-          // if (preview_lens_view_)
-          //   preview_lens_view_->PopFilterExpansion();
+          // if (preview_scope_view_)
+          //   preview_scope_view_->PopFilterExpansion();
         }
       });
 
@@ -445,14 +447,14 @@
   }
 
   // reset the saturation.
-  if (preview_lens_view_.IsValid())
+  if (preview_scope_view_.IsValid())
   {
-    preview_lens_view_->SetResultsPreviewAnimationValue(0.0);
-    preview_lens_view_->ForceCategoryExpansion(stored_activated_unique_id_, false);
-    preview_lens_view_->EnableResultTextures(false);
-    preview_lens_view_->PopFilterExpansion();
+    preview_scope_view_->SetResultsPreviewAnimationValue(0.0);
+    preview_scope_view_->ForceCategoryExpansion(stored_activated_unique_id_, false);
+    preview_scope_view_->EnableResultTextures(false);
+    preview_scope_view_->PopFilterExpansion();
   }
-  preview_lens_view_.Release();
+  preview_scope_view_.Release();
   content_view_->SetPresentRedirectedView(true);
 }
 
@@ -462,31 +464,13 @@
   visible_ = true;
   search_bar_->text_entry()->SelectAll();
 
-  /* Give the lenses a chance to prep data before we map them  */
-  lens_bar_->Activate(active_lens_view_->lens()->id());
-  if (active_lens_view_)
-  {
-    active_lens_view_->SetVisible(true);
-
-    if (active_lens_view_->lens()->id() == "home.lens")
-    {
-      for (auto lens : lenses_.GetLenses())
-      {
-        lens->view_type = ViewType::HOME_VIEW;
-        LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HOME_VIEW
-                              << " on '" << lens->id() << "'";
-      }
-
-      home_lens_->view_type = ViewType::LENS_VIEW;
-      LOG_DEBUG(logger) << "Setting ViewType " << ViewType::LENS_VIEW
-                                  << " on '" << home_lens_->id() << "'";
-    }
-    else
-    {
-      // careful here, the lens_view's view_type doesn't get reset when the dash
-      // hides, but lens' view_type does, so we need to update the lens directly
-      active_lens_view_->lens()->view_type = ViewType::LENS_VIEW;
-    }
+  /* Give the scopes a chance to prep data before we map them  */
+  if (active_scope_view_)
+  { 
+    scope_bar_->Activate(active_scope_view_->scope()->id());
+
+    active_scope_view_->SetVisible(true);
+    active_scope_view_->scope()->view_type = ScopeViewType::SCOPE_VIEW;
   }
 
   // this will make sure the spinner animates if the search takes a while
@@ -508,19 +492,18 @@
   visible_ = false;
   renderer_.AboutToHide();
 
-  for (auto lens : lenses_.GetLenses())
+  if (scopes_)
   {
-    lens->view_type = ViewType::HIDDEN;
-    LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HIDDEN
-                          << " on '" << lens->id() << "'";
+    for (auto scope : scopes_->GetScopes())
+    {
+      scope->view_type = ScopeViewType::HIDDEN;
+      LOG_DEBUG(logger) << "Setting ViewType " << ScopeViewType::HIDDEN
+                            << " on '" << scope->id() << "'";
+    }
   }
 
-  home_lens_->view_type = ViewType::HIDDEN;
-  LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HIDDEN
-                            << " on '" << home_lens_->id() << "'";
-
-  if (active_lens_view_.IsValid())
-    active_lens_view_->SetVisible(false);
+  if (active_scope_view_.IsValid())
+    active_scope_view_->SetVisible(false);
 
   // if a preview is open, close it
   if (preview_displaying_)
@@ -562,30 +545,22 @@
   search_bar_->live_search_reached.connect(sigc::mem_fun(this, &DashView::OnLiveSearchReached));
   search_bar_->showing_filters.changed.connect([&] (bool showing)
   {
-    if (active_lens_view_)
+    if (active_scope_view_)
     {
-      active_lens_view_->filters_expanded = showing;
+      active_scope_view_->filters_expanded = showing;
       QueueDraw();
     }
   });
   search_bar_layout_->AddView(search_bar_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
   content_layout_->SetSpecialArea(search_bar_->show_filters());
 
-  lenses_layout_ = new nux::VLayout();
-  content_layout_->AddLayout(lenses_layout_, 1, nux::MINOR_POSITION_START);
-
-  home_view_ = new LensView(home_lens_, nullptr);
-  home_view_->uri_activated.connect(sigc::mem_fun(this, &DashView::OnUriActivated));
-
-  AddChild(home_view_.GetPointer());
-  active_lens_view_ = home_view_;
-  lens_views_[home_lens_->id] = home_view_;
-  lenses_layout_->AddView(home_view_.GetPointer());
-
-  lens_bar_ = new LensBar();
-  AddChild(lens_bar_);
-  lens_bar_->lens_activated.connect(sigc::mem_fun(this, &DashView::OnLensBarActivated));
-  content_layout_->AddView(lens_bar_, 0, nux::MINOR_POSITION_CENTER);
+  scopes_layout_ = new nux::VLayout();
+  content_layout_->AddLayout(scopes_layout_, 1, nux::MINOR_POSITION_START);
+
+  scope_bar_ = new ScopeBar();
+  AddChild(scope_bar_);
+  scope_bar_->scope_activated.connect(sigc::mem_fun(this, &DashView::OnScopeBarActivated));
+  content_layout_->AddView(scope_bar_, 0, nux::MINOR_POSITION_CENTER);
 }
 
 void DashView::SetupUBusConnections()
@@ -609,8 +584,8 @@
   // kinda hacky, but it makes sure the content isn't so big that it throws
   // the bottom of the dash off the screen
   // not hugely happy with this, so FIXME
-  lenses_layout_->SetMaximumHeight (std::max(0, content_geo_.height - search_bar_->GetGeometry().height - lens_bar_->GetGeometry().height - style.GetDashViewTopPadding()));
-  lenses_layout_->SetMinimumHeight (std::max(0, content_geo_.height - search_bar_->GetGeometry().height - lens_bar_->GetGeometry().height - style.GetDashViewTopPadding()));
+  scopes_layout_->SetMaximumHeight (std::max(0, content_geo_.height - search_bar_->GetGeometry().height - scope_bar_->GetGeometry().height - style.GetDashViewTopPadding()));
+  scopes_layout_->SetMinimumHeight (std::max(0, content_geo_.height - search_bar_->GetGeometry().height - scope_bar_->GetGeometry().height - style.GetDashViewTopPadding()));
 
   layout_->SetMinMaxSize(content_geo_.width, content_geo_.y + content_geo_.height);
 
@@ -653,7 +628,7 @@
   height += style.GetDashViewTopPadding();
   height += search_bar_->GetGeometry().height;
   height += category_height * DASH_DEFAULT_CATEGORY_COUNT; // adding three categories
-  height += lens_bar_->GetGeometry().height;
+  height += scope_bar_->GetGeometry().height;
 
   // width/height shouldn't be bigger than the geo available.
   width = std::min(width, for_geo.width); // launcher width is taken into account in for_geo.
@@ -715,7 +690,7 @@
 
     graphics_engine.PushClippingRectangle(geo_split_clip);
 
-    if (preview_lens_view_.IsValid())
+    if (preview_scope_view_.IsValid())
     {    
       DrawPreviewResultTextures(graphics_engine, force_draw);
     }
@@ -762,29 +737,29 @@
     texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
     texxform.FlipVCoord(true);
 
-    // Lens Bar
-    texxform.uoffset = (lens_bar_->GetX() - content_view_->GetX())/(float)content_view_->GetWidth();
-    texxform.voffset = (lens_bar_->GetY() - content_view_->GetY())/(float)content_view_->GetHeight();
+    // Scope Bar
+    texxform.uoffset = (scope_bar_->GetX() - content_view_->GetX())/(float)content_view_->GetWidth();
+    texxform.voffset = (scope_bar_->GetY() - content_view_->GetY())/(float)content_view_->GetHeight();
 
-    int start_y = lens_bar_->GetY();
+    int start_y = scope_bar_->GetY();
     int final_y = geo_layout.y + geo_layout.height + PREVIEW_ICON_SPLIT_OFFSCREEN_OFFSET;
 
-    int lens_y = (1.0f - animate_split_value_) * start_y + (animate_split_value_ * final_y);
+    int scope_y = (1.0f - animate_split_value_) * start_y + (animate_split_value_ * final_y);
 
     graphics_engine.QRP_1Tex
     (
-      lens_bar_->GetX(),
-      lens_y,
-      lens_bar_->GetWidth(),
-      lens_bar_->GetHeight(),
+      scope_bar_->GetX(),
+      scope_y,
+      scope_bar_->GetWidth(),
+      scope_bar_->GetHeight(),
       content_view_->BackupTexture(),
       texxform,
       nux::Color((1.0-animate_split_value_), (1.0-animate_split_value_), (1.0-animate_split_value_), (1.0-animate_split_value_))
     );
 
-    split_clip.height = std::min(lens_y, geo_layout.height);
+    split_clip.height = std::min(scope_y, geo_layout.height);
 
-    if (active_lens_view_ && active_lens_view_->GetPushedFilterExpansion())
+    if (active_scope_view_ && active_scope_view_->GetPushedFilterExpansion())
     {
       // Search Bar
       texxform.uoffset = (search_bar_->GetX() - content_view_->GetX())/(float)content_view_->GetWidth();
@@ -797,7 +772,7 @@
       (
         search_bar_->GetX(),
         (1.0f - animate_split_value_) * start_y + (animate_split_value_ * final_y),
-        search_bar_->GetWidth() - active_lens_view_->filter_bar()->GetWidth(),
+        search_bar_->GetWidth() - active_scope_view_->filter_bar()->GetWidth(),
         search_bar_->GetHeight(),
         content_view_->BackupTexture(),
         texxform,
@@ -805,10 +780,10 @@
       );
 
       // Filter Bar
-      texxform.uoffset = (active_lens_view_->filter_bar()->GetX() -content_view_->GetX())/(float)content_view_->GetWidth();
+      texxform.uoffset = (active_scope_view_->filter_bar()->GetX() -content_view_->GetX())/(float)content_view_->GetWidth();
       texxform.voffset = (search_bar_->GetY() - content_view_->GetY())/(float)content_view_->GetHeight();
 
-      int start_x = active_lens_view_->filter_bar()->GetX();
+      int start_x = active_scope_view_->filter_bar()->GetX();
       int final_x = content_view_->GetX() + content_view_->GetWidth() + PREVIEW_ICON_SPLIT_OFFSCREEN_OFFSET;
 
       int filter_x = (1.0f - animate_split_value_) * start_x + (animate_split_value_ * final_x);
@@ -817,8 +792,8 @@
       (
         filter_x,
         search_bar_->GetY(),
-        active_lens_view_->filter_bar()->GetWidth(),
-        active_lens_view_->filter_bar()->GetY() + active_lens_view_->filter_bar()->GetHeight(),
+        active_scope_view_->filter_bar()->GetWidth(),
+        active_scope_view_->filter_bar()->GetY() + active_scope_view_->filter_bar()->GetHeight(),
         content_view_->BackupTexture(),
         texxform,
         nux::Color((1.0-animate_split_value_), (1.0-animate_split_value_), (1.0-animate_split_value_), (1.0-animate_split_value_))
@@ -935,7 +910,7 @@
   texxform.voffset = 0.0f;
   texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
 
-  std::vector<ResultViewTexture::Ptr> result_textures = preview_lens_view_->GetResultTextureContainers();
+  std::vector<ResultViewTexture::Ptr> result_textures = preview_scope_view_->GetResultTextureContainers();
   std::vector<ResultViewTexture::Ptr> top_textures;
   
   int height_concat_below = 0;
@@ -973,7 +948,7 @@
     // off the bottom
     if (geo_tex_top.y <= geo_layout.y + geo_layout.height)
     {
-      preview_lens_view_->RenderResultTexture(result_texture);
+      preview_scope_view_->RenderResultTexture(result_texture);
       // If we haven't got it now, we're not going to get it
       if (!result_texture->texture.IsValid())
         continue;
@@ -1014,7 +989,7 @@
     // off the top
     if (geo_tex_top.y + geo_tex_top.height >= geo_layout.y)
     {
-      preview_lens_view_->RenderResultTexture(result_texture);
+      preview_scope_view_->RenderResultTexture(result_texture);
       // If we haven't got it now, we're not going to get it
       if (!result_texture->texture.IsValid())
         continue;
@@ -1106,11 +1081,11 @@
 {
   glib::String uri;
   glib::String search_string;
-  dash::HandledType handled_type;
+  ScopeHandledType handled_type;
 
   g_variant_get(args, "(sus)", &uri, &handled_type, &search_string);
 
-  std::string id(AnalyseLensURI(uri.Str()));
+  std::string id(AnalyseScopeURI(uri.Str()));
 
   // we got an activation request, we should probably close the preview
   if (preview_displaying_)
@@ -1120,43 +1095,43 @@
 
   if (!visible_)
   {
-    lens_bar_->Activate(id);
+    scope_bar_->Activate(id);
     ubus_manager_.SendMessage(UBUS_DASH_EXTERNAL_ACTIVATION);
   }
-  else if (/* visible_ && */ handled_type == NOT_HANDLED)
+  else if (/* visible_ && */ handled_type == ScopeHandledType::NOT_HANDLED)
   {
     ubus_manager_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST, NULL,
                               glib::Source::Priority::HIGH);
   }
-  else if (/* visible_ && */ handled_type == GOTO_DASH_URI)
+  else if (/* visible_ && */ handled_type == ScopeHandledType::GOTO_DASH_URI)
   {
-    lens_bar_->Activate(id);
+    scope_bar_->Activate(id);
   }
 }
 
-std::string DashView::AnalyseLensURI(std::string const& uri)
+std::string DashView::AnalyseScopeURI(std::string const& uri)
 {
-  impl::LensFilter filter = impl::parse_lens_uri(uri);
+  impl::ScopeFilter filter = impl::parse_scope_uri(uri);
 
   if (!filter.filters.empty())
   {
-    lens_views_[filter.id]->filters_expanded = true;
-    // update the lens for each filter
+    scope_views_[filter.id]->filters_expanded = true;
+    // update the scope for each filter
     for (auto p : filter.filters) {
-      UpdateLensFilter(filter.id, p.first, p.second);
+      UpdateScopeFilter(filter.id, p.first, p.second);
     }
   }
 
   return filter.id;
 }
 
-void DashView::UpdateLensFilter(std::string lens_id, std::string filter_name, std::string value)
+void DashView::UpdateScopeFilter(std::string scope_id, std::string filter_name, std::string value)
 {
-  if (lenses_.GetLens(lens_id))
+  if (scopes_ && scopes_->GetScope(scope_id))
   {
-    Lens::Ptr lens = lenses_.GetLens(lens_id);
+    Scope::Ptr scope = scopes_->GetScope(scope_id);
 
-    Filters::Ptr filters = lens->filters;
+    Filters::Ptr filters = scope->filters;
 
     for (unsigned int i = 0; i < filters->count(); ++i)
     {
@@ -1164,13 +1139,13 @@
 
       if (filter->id() == filter_name)
       {
-        UpdateLensFilterValue(filter, value);
+        UpdateScopeFilterValue(filter, value);
       }
     }
   }
 }
 
-void DashView::UpdateLensFilterValue(Filter::Ptr filter, std::string value)
+void DashView::UpdateScopeFilterValue(Filter::Ptr filter, std::string value)
 {
   if (filter->renderer_name == "filter-radiooption")
   {
@@ -1186,7 +1161,7 @@
 void DashView::OnSearchChanged(std::string const& search_string)
 {
   LOG_DEBUG(logger) << "Search changed: " << search_string;
-  if (active_lens_view_)
+  if (active_scope_view_)
   {
     search_in_progress_ = true;
     // it isn't guaranteed that we get a SearchFinished signal, so we need
@@ -1201,7 +1176,7 @@
 
     // 150ms to hide the no reults message if its take a while to return results
     hide_message_delay_.reset(new glib::Timeout(150, [&] () {
-      active_lens_view_->HideResultsMessage();
+      active_scope_view_->HideResultsMessage();
       return false;
     }));
   }
@@ -1210,67 +1185,63 @@
 void DashView::OnLiveSearchReached(std::string const& search_string)
 {
   LOG_DEBUG(logger) << "Live search reached: " << search_string;
-  if (active_lens_view_)
+  if (active_scope_view_)
   {
-    active_lens_view_->PerformSearch(search_string,
+    active_scope_view_->PerformSearch(search_string,
         sigc::mem_fun(this, &DashView::OnSearchFinished));
   }
 }
 
-void DashView::OnLensAdded(Lens::Ptr& lens)
+void DashView::OnScopeAdded(Scope::Ptr const& scope, int position)
 {
-  std::string id = lens->id;
-  lens_bar_->AddLens(lens);
-
-  nux::ObjectPtr<LensView> view(new LensView(lens, search_bar_->show_filters()));
+  LOG_DEBUG(logger) << "Scope Added: " << scope->id();
+
+  std::string id = scope->id;
+  scope_bar_->AddScope(scope);
+
+  nux::ObjectPtr<ScopeView> view(new ScopeView(scope, search_bar_->show_filters()));
   AddChild(view.GetPointer());
   view->SetVisible(false);
   view->uri_activated.connect(sigc::mem_fun(this, &DashView::OnUriActivated));
 
-  lenses_layout_->AddView(view.GetPointer(), 1);
-  lens_views_[lens->id] = view;
+  scopes_layout_->AddView(view.GetPointer(), 1);
+  scope_views_[scope->id] = view;
 
-  lens->activated.connect(sigc::mem_fun(this, &DashView::OnUriActivatedReply));
-  lens->connected.changed.connect([&] (bool value)
-  {
-    std::string const& search_string = search_bar_->search_string;
-    if (value && lens->search_in_global && active_lens_view_ == home_view_
-        && !search_string.empty())
-    {
-      // force a (global!) search with the correct string
-      lens->GlobalSearch(search_bar_->search_string,
-        sigc::mem_fun(this, &DashView::OnSearchFinished));
-    }
-  });
+  scope->activated.connect(sigc::mem_fun(this, &DashView::OnUriActivatedReply));
+  scope->connected.changed.connect([&] (bool value) { });
 
   // Hook up to the new preview infrastructure
-  lens->preview_ready.connect([&] (std::string const& uri, Preview::Ptr model)
+  scope->preview_ready.connect([&] (std::string const& uri, Preview::Ptr model)
   {
     LOG_DEBUG(logger) << "Got preview for: " << uri;
     preview_state_machine_.ActivatePreview(model); // this does not immediately display a preview - we now wait.
   });
+
+  if (!active_scope_view_)
+    OnScopeBarActivated(scope->id());
 }
 
-void DashView::OnLensBarActivated(std::string const& id)
+void DashView::OnScopeBarActivated(std::string const& id)
 {
-  if (lens_views_.find(id) == lens_views_.end())
+  if (scope_views_.find(id) == scope_views_.end())
   {
-    LOG_WARN(logger) << "Unable to find Lens " << id;
+    LOG_WARN(logger) << "Unable to find Scope " << id;
     return;
   }
 
-  if (active_lens_view_.IsValid())
-    active_lens_view_->SetVisible(false);
+  if (active_scope_view_.IsValid())
+    active_scope_view_->SetVisible(false);
+  scope_can_refine_connection_.disconnect();
 
-  nux::ObjectPtr<LensView> view = active_lens_view_ = lens_views_[id];
+  nux::ObjectPtr<ScopeView> view = active_scope_view_ = scope_views_[id];
 
   view->SetVisible(true);
   view->AboutToShow();
 
-  for (auto it: lens_views_)
+  for (auto it: scope_views_)
   {
     bool id_matches = it.first == id;
-    ViewType view_type = id_matches ? LENS_VIEW : (view == home_view_ ? HOME_VIEW : HIDDEN);
+    ScopeViewType view_type = id_matches ? ScopeViewType::SCOPE_VIEW : ScopeViewType::HIDDEN;
     it.second->SetVisible(id_matches);
     it.second->view_type = view_type;
 
@@ -1281,8 +1252,8 @@
   search_bar_->SetVisible(true);
   QueueRelayout();
   search_bar_->search_string = view->search_string;
-  search_bar_->search_hint = view->lens()->search_hint;
-  // lenses typically return immediately from Search() if the search query
+  search_bar_->search_hint = view->scope()->search_hint;
+  // scopes typically return immediately from Search() if the search query
   // doesn't change, so SearchFinished will be called in a few ms
   // FIXME: if we're forcing a search here, why don't we get rid of view types?
   search_bar_->ForceSearchChanged();
@@ -1294,23 +1265,26 @@
 
   search_bar_->text_entry()->SelectAll();
   search_bar_->can_refine_search = view->can_refine_search();
+  scope_can_refine_connection_ = view->can_refine_search.changed.connect([this] (bool can_refine_search) {
+    search_bar_->can_refine_search = can_refine_search;
+  });
   hide_message_delay_.reset();
 
   view->QueueDraw();
   QueueDraw();
 }
 
-void DashView::OnSearchFinished(Lens::Hints const& hints, glib::Error const& err)
+void DashView::OnSearchFinished(glib::HintsMap const& hints, glib::Error const& err)
 {
   hide_message_delay_.reset();
 
-  if (!active_lens_view_.IsValid()) return;
+  if (!active_scope_view_.IsValid()) return;
 
-  // FIXME: bind the lens_view in PerformSearch
-  active_lens_view_->CheckNoResults(hints);
+  // FIXME: bind the scope_view in PerformSearch
+  active_scope_view_->CheckNoResults(hints);
   std::string const& search_string = search_bar_->search_string;
 
-  if (active_lens_view_->search_string == search_string)
+  if (active_scope_view_->search_string == search_string)
   {
     search_bar_->SearchFinished();
     search_in_progress_ = false;
@@ -1319,29 +1293,7 @@
   }
 }
 
-void DashView::OnGlobalSearchFinished(Lens::Hints const& hints, glib::Error const& error)
-{
-  if (active_lens_view_ == home_view_)
-    OnSearchFinished(hints, error);
-}
-
-void DashView::OnAppsGlobalSearchFinished(Lens::Ptr const& lens)
-{
-  if (active_lens_view_ == home_view_ && lens->id() == "applications.lens")
-  {
-    /* HACKITY HACK! We're resetting the state of search_in_progress when
-     * doing searches in the home lens and we get results from apps lens.
-     * This way typing a search query and pressing enter immediately will
-     * wait for the apps lens results and will run correct application.
-     * See lp:966417 and lp:856206 for more info about why we do this.
-     */
-    search_in_progress_ = false;
-    if (activate_on_finish_)
-      this->OnEntryActivated();
-  }
-}
-
-void DashView::OnUriActivatedReply(std::string const& uri, HandledType type, Lens::Hints const&)
+void DashView::OnUriActivatedReply(std::string const& uri, ScopeHandledType type, glib::HintsMap const&)
 {
   // We don't want to close the dash if there was another activation pending
   if (type == NOT_HANDLED)
@@ -1362,11 +1314,11 @@
   size_t pos = fake_uri.find(":");
   std::string uri = fake_uri.substr(++pos);
 
-  LOG_DEBUG(logger) << "Fallback activating " << uri;
-
   if (g_str_has_prefix(uri.c_str(), "application://"))
   {
     std::string appname = uri.substr(14);
+
+    printf("Actrivating app: %s", appname.c_str());
     return LaunchApp(appname);
   }
   else if (g_str_has_prefix(uri.c_str(), "unity-runner://"))
@@ -1436,9 +1388,9 @@
 }
 void DashView::OnEntryActivated()
 {
-  if (active_lens_view_.IsValid() && !search_in_progress_)
+  if (active_scope_view_.IsValid() && !search_in_progress_)
   {
-    active_lens_view_->ActivateFirst();
+    active_scope_view_->ActivateFirst();
   }
   // delay the activation until we get the SearchFinished signal
   activate_on_finish_ = search_in_progress_;
@@ -1452,9 +1404,9 @@
 
 std::string const DashView::GetIdForShortcutActivation(std::string const& shortcut) const
 {
-  Lens::Ptr lens = lenses_.GetLensForShortcut(shortcut);
-  if (lens)
-    return lens->id;
+  Scope::Ptr scope = scopes_ ? scopes_->GetScopeForShortcut(shortcut) : Scope::Ptr();
+  if (scope)
+    return scope->id;
   return "";
 }
 
@@ -1462,11 +1414,14 @@
 {
   std::vector<char> result;
 
-  for (Lens::Ptr lens: lenses_.GetLenses())
+  if (scopes_)
   {
-    std::string shortcut = lens->shortcut;
-    if(shortcut.size() > 0)
-      result.push_back(shortcut.at(0));
+    for (Scope::Ptr scope: scopes_->GetScopes())
+    {
+      std::string shortcut = scope->shortcut;
+      if(shortcut.size() > 0)
+        result.push_back(shortcut.at(0));
+    }
   }
   return result;
 }
@@ -1505,8 +1460,8 @@
   dash::Style& style = dash::Style::Instance();
   int num_rows = 1; // The search bar
 
-  if (active_lens_view_.IsValid())
-    num_rows += active_lens_view_->GetNumRows();
+  if (active_scope_view_.IsValid())
+    num_rows += active_scope_view_->GetNumRows();
 
   std::string form_factor("unknown");
 
@@ -1533,17 +1488,17 @@
   {
     return preview_container_->KeyNavIteration(direction);
   }
-  else if (direction == nux::KEY_NAV_DOWN && search_bar_ && active_lens_view_.IsValid())
+  else if (direction == nux::KEY_NAV_DOWN && search_bar_ && active_scope_view_.IsValid())
   {
     auto show_filters = search_bar_->show_filters();
-    auto fscroll_view = active_lens_view_->fscroll_view();
+    auto fscroll_view = active_scope_view_->fscroll_view();
 
     if (show_filters && show_filters->HasKeyFocus())
     {
       if (fscroll_view->IsVisible() && fscroll_view)
         return fscroll_view->KeyNavIteration(direction);
       else
-        return active_lens_view_->KeyNavIteration(direction);
+        return active_scope_view_->KeyNavIteration(direction);
     }
   }
   return this;
@@ -1621,9 +1576,9 @@
   if (direction != KEY_NAV_NONE && key_symbol == nux::NUX_KEYDOWN && !search_bar_->im_preedit)
   {
     std::list<nux::Area*> tabs;
-    if (active_lens_view_.IsValid())
+    if (active_scope_view_.IsValid())
     {
-      for (auto category : active_lens_view_->categories())
+      for (auto category : active_scope_view_->categories())
       {
         if (category->IsVisible())
           tabs.push_back(category);
@@ -1636,11 +1591,11 @@
       tabs.push_back(search_bar_->show_filters());
     }
 
-    if (active_lens_view_.IsValid() &&
-        active_lens_view_->filter_bar() && active_lens_view_->fscroll_view() &&
-        active_lens_view_->fscroll_view()->IsVisible())
+    if (active_scope_view_.IsValid() &&
+        active_scope_view_->filter_bar() && active_scope_view_->fscroll_view() &&
+        active_scope_view_->fscroll_view()->IsVisible())
     {
-      for (auto child : active_lens_view_->filter_bar()->GetLayout()->GetChildren())
+      for (auto child : active_scope_view_->filter_bar()->GetLayout()->GetChildren())
       {
         FilterExpanderLabel* filter = dynamic_cast<FilterExpanderLabel*>(child);
         if (filter)
@@ -1652,7 +1607,7 @@
     {
       if (ctrl)
       {
-        lens_bar_->ActivatePrevious();
+        scope_bar_->ActivatePrevious();
       }
       else
       {
@@ -1679,7 +1634,7 @@
     {
       if (ctrl)
       {
-        lens_bar_->ActivateNext();
+        scope_bar_->ActivateNext();
       }
       else
       {
 
=== modified file 'dash/DashView.h'
--- dash/DashView.h	2013-01-28 23:57:38 +0000
+++ dash/DashView.h	2013-02-21 10:37:29 +0000
@@ -24,8 +24,7 @@
 #include <Nux/View.h>
 #include <Nux/VLayout.h>
 
-#include <UnityCore/FilesystemLenses.h>
-#include <UnityCore/HomeLens.h>
+#include <UnityCore/Scopes.h>
 #include <UnityCore/GLibSource.h>
 
 #include "LensBar.h"
@@ -55,10 +54,12 @@
 class DashView : public nux::View, public unity::debug::Introspectable
 {
   NUX_DECLARE_OBJECT_TYPE(DashView, nux::View);
-  typedef std::map<std::string, nux::ObjectPtr<LensView>> LensViews;
+  typedef std::map<std::string, nux::ObjectPtr<ScopeView>> ScopeViews;
 
 public:
-  DashView();
+  typedef std::function<void()> ScopesCreator;
+
+  DashView(ScopesCreator scopes_creator = nullptr);
   ~DashView();
 
   void AboutToShow();
@@ -108,20 +109,17 @@
   void OnBackgroundColorChanged(GVariant* args);
   void OnSearchChanged(std::string const& search_string);
   void OnLiveSearchReached(std::string const& search_string);
-  void OnLensAdded(Lens::Ptr& lens);
-  void OnLensBarActivated(std::string const& id);
-  void OnSearchFinished(Lens::Hints const& hints, glib::Error const& error);
-  void OnGlobalSearchFinished(Lens::Hints const& hints, glib::Error const& error);
-  void OnAppsGlobalSearchFinished(Lens::Ptr const& lens);
+  void OnScopeAdded(Scope::Ptr const& scope, int position);
+  void OnScopeBarActivated(std::string const& id);
+  void OnSearchFinished(glib::HintsMap const& hints, glib::Error const& error);
   void OnUriActivated(ResultView::ActivateType type, std::string const& uri, GVariant* data, std::string const& unique_id);
-  void OnUriActivatedReply(std::string const& uri, HandledType type, Lens::Hints const&);
+  void OnUriActivatedReply(std::string const& uri, ScopeHandledType type, glib::HintsMap const& hints);
   bool DoFallbackActivation(std::string const& uri);
   bool LaunchApp(std::string const& appname);
   void OnEntryActivated();
-  std::string AnalyseLensURI(std::string const& uri);
-  void UpdateLensFilter(std::string lens, std::string filter, std::string value);
-  void UpdateLensFilterValue(Filter::Ptr filter, std::string value);
-  void EnsureLensesInitialized();
+  std::string AnalyseScopeURI(std::string const& uri);
+  void UpdateScopeFilter(std::string scope_id, std::string filter, std::string value);
+  void UpdateScopeFilterValue(Filter::Ptr filter, std::string value);
 
   bool AcceptKeyNavFocus();
   bool InspectKeyEvent(unsigned int eventType, unsigned int key_sym, const char* character);
@@ -131,9 +129,8 @@
   nux::Area* KeyNavIteration(nux::KeyNavDirection direction);
 
   UBusManager ubus_manager_;
-  FilesystemLenses lenses_;
-  HomeLens::Ptr home_lens_;
-  LensViews lens_views_;
+  Scopes::Ptr scopes_;
+  ScopeViews scope_views_;
 
   // View related
   PreviewStateMachine preview_state_machine_;
@@ -147,12 +144,12 @@
   nux::View* content_view_;
   nux::HLayout* search_bar_layout_;
   SearchBar* search_bar_;
-  nux::VLayout* lenses_layout_;
-  LensBar* lens_bar_;
+  nux::VLayout* scopes_layout_;
+  ScopeBar* scope_bar_;
 
-  nux::ObjectPtr<LensView> home_view_;
-  nux::ObjectPtr<LensView> active_lens_view_;
-  nux::ObjectPtr<LensView> preview_lens_view_;
+  nux::ObjectPtr<ScopeView> active_scope_view_;
+  nux::ObjectPtr<ScopeView> preview_scope_view_;
+  sigc::connection scope_can_refine_connection_;
 
   // Drawing related
   nux::Geometry content_geo_;
@@ -165,6 +162,7 @@
 
   bool visible_;
 
+  glib::Source::UniquePtr init_timeout_;
   glib::Source::UniquePtr searching_timeout_;
   glib::Source::UniquePtr hide_message_delay_;
 
 
=== modified file 'dash/DashViewPrivate.cpp'
--- dash/DashViewPrivate.cpp	2012-05-06 23:48:38 +0000
+++ dash/DashViewPrivate.cpp	2013-02-21 10:37:29 +0000
@@ -28,9 +28,9 @@
 namespace impl
 {
 
-LensFilter parse_lens_uri(std::string const& uri)
+ScopeFilter parse_scope_uri(std::string const& uri)
 {
-  LensFilter filter;
+  ScopeFilter filter;
 
   filter.id = uri;
   std::size_t pos = uri.find("?");
 
=== modified file 'dash/DashViewPrivate.h'
--- dash/DashViewPrivate.h	2012-05-06 23:48:38 +0000
+++ dash/DashViewPrivate.h	2013-02-21 10:37:29 +0000
@@ -35,7 +35,9 @@
   std::map<std::string, std::string> filters;
 };
 
-LensFilter parse_lens_uri(std::string const& uri);
+typedef LensFilter ScopeFilter;
+
+ScopeFilter parse_scope_uri(std::string const& uri);
 
 } // namespace impl
 } // namespace dash
 
=== modified file 'dash/FilterBar.cpp'
--- dash/FilterBar.cpp	2012-11-27 23:37:20 +0000
+++ dash/FilterBar.cpp	2013-02-21 10:37:29 +0000
@@ -33,17 +33,13 @@
 {
 namespace dash
 {
-DECLARE_LOGGER(logger, "unity.dash.filter.bar");
+DECLARE_LOGGER(logger, "unity.dash.filterbar");
 
 NUX_IMPLEMENT_OBJECT_TYPE(FilterBar);
 
 FilterBar::FilterBar(NUX_FILE_LINE_DECL)
   : View(NUX_FILE_LINE_PARAM)
 {
-  // TODO - does the filterbar associate itself with a model of some sort?
-  // does libunity provide a Lens.Filters model or something that we can update on?
-  // don't want to associate a Filterbar with just a lens model, its a filter bar not a
-  // lens parser
   Init();
 }
 
@@ -95,6 +91,17 @@
   }
 }
 
+void FilterBar::ClearFilters()
+{
+  for (auto iter: filter_map_)
+  {
+    FilterExpanderLabel* filter_view = iter.second;
+    RemoveChild(filter_view);
+    GetLayout()->RemoveChildObject(filter_view);
+  }
+  filter_map_.clear();
+}
+
 void FilterBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
 
 
=== modified file 'dash/FilterBar.h'
--- dash/FilterBar.h	2012-09-13 13:15:29 +0000
+++ dash/FilterBar.h	2013-02-21 10:37:29 +0000
@@ -48,6 +48,7 @@
 
   void AddFilter(Filter::Ptr const& filter);
   void RemoveFilter(Filter::Ptr const& filter);
+  void ClearFilters();
 
 protected:
   virtual bool AcceptKeyNavFocus();
 
=== modified file 'dash/FilterRatingsButton.cpp'
--- dash/FilterRatingsButton.cpp	2012-12-18 11:41:38 +0000
+++ dash/FilterRatingsButton.cpp	2013-02-21 10:37:29 +0000
@@ -90,7 +90,7 @@
   // FIXME: 9/26/2011
   // We should probably support an API for saying whether the ratings
   // should or shouldn't support half stars...but our only consumer at
-  // the moment is the applications lens which according to design
+  // the moment is the applications scope which according to design
   // (Bug #839759) shouldn't. So for now just force rounding.
   //    int total_half_stars = rating % 2;
   //    int total_full_stars = rating / 2;
 
=== modified file 'dash/LensBar.cpp'
--- dash/LensBar.cpp	2012-12-17 18:00:40 +0000
+++ dash/LensBar.cpp	2013-02-21 10:37:29 +0000
@@ -27,25 +27,24 @@
 #include "unity-shared/StaticCairoText.h"
 #include "unity-shared/CairoTexture.h"
 #include "unity-shared/GraphicsUtils.h"
-#include "LensBar.h"
 #include "unity-shared/UBusMessages.h"
 
 namespace unity
 {
 namespace dash
 {
-DECLARE_LOGGER(logger, "unity.dash.lensbar");
+DECLARE_LOGGER(logger, "unity.dash.scopebar");
 namespace
 {
-// according to Q design the inner area of the lensbar should be 40px
+// according to Q design the inner area of the scopebar should be 40px
 // (without any borders)
-const int LENSBAR_HEIGHT = 41;
+const int SCOPEBAR_HEIGHT = 41;
 
 }
 
-NUX_IMPLEMENT_OBJECT_TYPE(LensBar);
+NUX_IMPLEMENT_OBJECT_TYPE(ScopeBar);
 
-LensBar::LensBar()
+ScopeBar::ScopeBar()
   : nux::View(NUX_TRACKER_LOCATION)
   , info_previously_shown_(false)
 {
@@ -55,10 +54,9 @@
 
   SetupBackground();
   SetupLayout();
-  SetupHomeLens();
 }
 
-void LensBar::SetupBackground()
+void ScopeBar::SetupBackground()
 {
   nux::ROPConfig rop;
   rop.Blend = true;
@@ -67,7 +65,7 @@
   bg_layer_.reset(new nux::ColorLayer(nux::Color(0.0f, 0.0f, 0.0f, 0.2f), true, rop));
 }
 
-void LensBar::SetupLayout()
+void ScopeBar::SetupLayout()
 {
   legal_layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
   std::string legal_text("<span underline='single'>");
@@ -113,24 +111,11 @@
 
   SetLayout(layered_layout_);
   
-  SetMinimumHeight(LENSBAR_HEIGHT);
-  SetMaximumHeight(LENSBAR_HEIGHT);
-}
-
-void LensBar::SetupHomeLens()
-{
-  LensBarIcon* icon = new LensBarIcon("home.lens", PKGDATADIR"/lens-nav-home.svg");
-  icon->SetVisible(true);
-  icon->active = true;
-  icons_.push_back(icon);
-  layout_->AddView(icon, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
-  AddChild(icon);
-
-  icon->mouse_click.connect([&, icon] (int x, int y, unsigned long button, unsigned long keyboard) { SetActive(icon); });
-  icon->key_nav_focus_activate.connect([&, icon](nux::Area*){ SetActive(icon); });
-}
-
-void LensBar::DoOpenLegalise()
+  SetMinimumHeight(SCOPEBAR_HEIGHT);
+  SetMaximumHeight(SCOPEBAR_HEIGHT);
+}
+
+void ScopeBar::DoOpenLegalise()
 {
   glib::Error error;
   std::string legal_file_path = "file://";
@@ -147,11 +132,12 @@
   ubus_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
 }
 
-void LensBar::AddLens(Lens::Ptr& lens)
+void ScopeBar::AddScope(Scope::Ptr const& scope)
 {
-  LensBarIcon* icon = new LensBarIcon(lens->id, lens->icon_hint);
-  icon->SetVisible(lens->visible);
-  lens->visible.changed.connect([icon](bool visible) { icon->SetVisible(visible); } );
+  ScopeBarIcon* icon = new ScopeBarIcon(scope->id, scope->icon_hint);
+
+  icon->SetVisible(scope->visible);
+  scope->visible.changed.connect([icon](bool visible) { icon->SetVisible(visible); } );
   icons_.push_back(icon);
   layout_->AddView(icon, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
   AddChild(icon);
@@ -160,7 +146,7 @@
   icon->key_nav_focus_activate.connect([&, icon](nux::Area*){ SetActive(icon); });
 }
 
-void LensBar::Activate(std::string id)
+void ScopeBar::Activate(std::string id)
 {
   for (auto icon: icons_)
   {
@@ -172,7 +158,7 @@
   }
 }
 
-void LensBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+void ScopeBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& base = GetGeometry();
 
@@ -190,7 +176,7 @@
   graphics_engine.PopClippingRectangle();
 }
 
-void LensBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
+void ScopeBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& base = GetGeometry();
 
@@ -201,7 +187,7 @@
   {
     if (RedirectedAncestor())
     { 
-      // Whole Lens bar needs to be cleared because the PaintAll forces redraw.
+      // Whole Scope bar needs to be cleared because the PaintAll forces redraw.
       graphics::ClearGeometry(base);
     }
 
@@ -251,10 +237,10 @@
   graphics_engine.PopClippingRectangle();
 }
 
-nux::Area* LensBar::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
+nux::Area* ScopeBar::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
 {
   //LayeredLayout is acting a little screwy, events are not passing past the first layout like instructed,
-  //so we manually override if the cursor is on the right hand side of the lensbar 
+  //so we manually override if the cursor is on the right hand side of the scopebar 
   auto geo = GetAbsoluteGeometry();
   int info_width = (info_previously_shown_) ? info_icon_->GetGeometry().width : legal_->GetGeometry().width;
   
@@ -272,7 +258,7 @@
   
 }
 
-void LensBar::SetActive(LensBarIcon* activated)
+void ScopeBar::SetActive(ScopeBarIcon* activated)
 {
   bool state_changed = false;
 
@@ -287,13 +273,13 @@
   }
 
   if (state_changed)
-    lens_activated.emit(activated->id);
+    scope_activated.emit(activated->id);
 }
 
-void LensBar::ActivateNext()
+void ScopeBar::ActivateNext()
 {
-  // Special case when switching from the command lens.
-  if (GetActiveLensId() == "commands.lens")
+  // Special case when switching from the command scope.
+  if (GetActiveScopeId() == "commands.scope")
   {
     SetActive(icons_[0]);
     return;
@@ -304,7 +290,7 @@
        it < icons_.end();
        it++)
   {
-    LensBarIcon *icon = *it;
+    ScopeBarIcon *icon = *it;
 
     if (activate_next && icon->IsVisible())
     {
@@ -318,10 +304,10 @@
 
 }
 
-void LensBar::ActivatePrevious()
+void ScopeBar::ActivatePrevious()
 {
-  // Special case when switching from the command lens.
-  if (GetActiveLensId() == "commands.lens")
+  // Special case when switching from the command scope.
+  if (GetActiveScopeId() == "commands.scope")
   {
     SetActive(icons_.back());
     return;
@@ -332,7 +318,7 @@
        it < icons_.rend();
        ++it)
   {
-    LensBarIcon *icon = *it;
+    ScopeBarIcon *icon = *it;
 
     if (activate_previous && icon->IsVisible())
     {
@@ -347,34 +333,34 @@
 }
 
 // Keyboard navigation
-bool LensBar::AcceptKeyNavFocus()
+bool ScopeBar::AcceptKeyNavFocus()
 {
   return false;
 }
 
 // Introspectable
-std::string LensBar::GetName() const
+std::string ScopeBar::GetName() const
 {
-  return "LensBar";
+  return "ScopeBar";
 }
 
-void LensBar::AddProperties(GVariantBuilder* builder)
+void ScopeBar::AddProperties(GVariantBuilder* builder)
 {
   unity::variant::BuilderWrapper wrapper(builder);
 
-  wrapper.add("focused-lens-icon", "");
+  wrapper.add("focused-scope-icon", "");
 
   for( auto icon : icons_)
   {
     if (icon->active)
-      wrapper.add("active-lens", icon->id.Get());
+      wrapper.add("active-scope", icon->id.Get());
 
     if (icon->HasKeyFocus())
-      wrapper.add("focused-lens-icon", icon->id.Get());
+      wrapper.add("focused-scope-icon", icon->id.Get());
   }
 }
 
-std::string LensBar::GetActiveLensId() const
+std::string ScopeBar::GetActiveScopeId() const
 {
   for (auto icon : icons_)
   {
 
=== modified file 'dash/LensBar.h'
--- dash/LensBar.h	2012-12-14 12:14:34 +0000
+++ dash/LensBar.h	2013-02-21 10:37:29 +0000
@@ -27,7 +27,7 @@
 #include <Nux/Nux.h>
 #include <Nux/PaintLayer.h>
 #include <Nux/View.h>
-#include <UnityCore/Lens.h>
+#include <UnityCore/Scope.h>
 
 #include "unity-shared/IconTexture.h"
 #include "unity-shared/Introspectable.h"
@@ -49,25 +49,24 @@
 namespace dash
 {
 
-class LensBar : public nux::View, public unity::debug::Introspectable
+class ScopeBar : public nux::View, public unity::debug::Introspectable
 {
-  NUX_DECLARE_OBJECT_TYPE(LensBar, nux::View);
-  typedef std::vector<LensBarIcon*> LensIcons;
+  NUX_DECLARE_OBJECT_TYPE(ScopeBar, nux::View);
+  typedef std::vector<ScopeBarIcon*> ScopeIcons;
 
 public:
-  LensBar();
+  ScopeBar();
 
-  void AddLens(Lens::Ptr& lens);
+  void AddScope(Scope::Ptr const& scope);
   void Activate(std::string id);
   void ActivateNext();
   void ActivatePrevious();
 
-  sigc::signal<void, std::string const&> lens_activated;
+  sigc::signal<void, std::string const&> scope_activated;
 
 private:
   void SetupBackground();
   void SetupLayout();
-  void SetupHomeLens();
   void DoOpenLegalise();
 
   void Draw(nux::GraphicsEngine& gfx_context, bool force_draw);
@@ -75,16 +74,16 @@
 
   nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type);
 
-  void SetActive(LensBarIcon* icon);
+  void SetActive(ScopeBarIcon* icon);
 
   bool AcceptKeyNavFocus();
   std::string GetName() const;
   void AddProperties(GVariantBuilder* builder);
 
-  std::string GetActiveLensId() const;
+  std::string GetActiveScopeId() const;
   typedef std::unique_ptr<nux::AbstractPaintLayer> LayerPtr;
 
-  LensIcons icons_;
+  ScopeIcons icons_;
 
   UBusManager ubus_;
 
@@ -97,6 +96,8 @@
 
   bool info_previously_shown_;
   std::string legal_seen_file_path_;
+
+  friend class TestScopeBar;
 };
 
 } // namespace dash
 
=== modified file 'dash/LensBarIcon.cpp'
--- dash/LensBarIcon.cpp	2012-12-17 09:28:31 +0000
+++ dash/LensBarIcon.cpp	2013-02-21 10:37:29 +0000
@@ -35,9 +35,9 @@
 
 }
 
-NUX_IMPLEMENT_OBJECT_TYPE(LensBarIcon);
+NUX_IMPLEMENT_OBJECT_TYPE(ScopeBarIcon);
 
-LensBarIcon::LensBarIcon(std::string id_, std::string icon_hint)
+ScopeBarIcon::ScopeBarIcon(std::string id_, std::string icon_hint)
   : IconTexture(icon_hint, 24)
   , id(id_)
   , active(false)
@@ -56,14 +56,14 @@
   SetAcceptKeyNavFocusOnMouseDown(false);
   SetAcceptKeyNavFocusOnMouseEnter(true);
 
-  active.changed.connect(sigc::mem_fun(this, &LensBarIcon::OnActiveChanged));
+  active.changed.connect(sigc::mem_fun(this, &ScopeBarIcon::OnActiveChanged));
   key_nav_focus_change.connect([&](nux::Area*, bool, nux::KeyNavDirection){ QueueDraw(); });
 }
 
-LensBarIcon::~LensBarIcon()
+ScopeBarIcon::~ScopeBarIcon()
 {}
 
-void LensBarIcon::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+void ScopeBarIcon::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& geo = GetGeometry();
 
@@ -109,18 +109,18 @@
   graphics_engine.PopClippingRectangle();
 }
 
-void LensBarIcon::OnActiveChanged(bool is_active)
+void ScopeBarIcon::OnActiveChanged(bool is_active)
 {
   QueueDraw();
 }
 
 // Introspectable
-std::string LensBarIcon::GetName() const
+std::string ScopeBarIcon::GetName() const
 {
-  return "LensBarIcon";
+  return "ScopeBarIcon";
 }
 
-void LensBarIcon::AddProperties(GVariantBuilder* builder)
+void ScopeBarIcon::AddProperties(GVariantBuilder* builder)
 {
   unity::variant::BuilderWrapper wrapper(builder);
 
 
=== modified file 'dash/LensBarIcon.h'
--- dash/LensBarIcon.h	2012-05-06 23:48:38 +0000
+++ dash/LensBarIcon.h	2013-02-21 10:37:29 +0000
@@ -33,12 +33,12 @@
 namespace dash
 {
 
-class LensBarIcon : public IconTexture
+class ScopeBarIcon : public IconTexture
 {
-  NUX_DECLARE_OBJECT_TYPE(LensBarIcon, IconTexture);
+  NUX_DECLARE_OBJECT_TYPE(ScopeBarIcon, IconTexture);
 public:
-  LensBarIcon(std::string id, std::string icon_hint);
-  ~LensBarIcon();
+  ScopeBarIcon(std::string id, std::string icon_hint);
+  ~ScopeBarIcon();
 
   nux::Property<std::string> id;
   nux::Property<bool> active;
 
=== modified file 'dash/LensView.cpp'
--- dash/LensView.cpp	2013-01-15 21:53:55 +0000
+++ dash/LensView.cpp	2013-02-21 10:37:29 +0000
@@ -43,7 +43,7 @@
 {
 namespace dash
 {
-DECLARE_LOGGER(logger, "unity.dash.lensview");
+DECLARE_LOGGER(logger, "unity.dash.scopeview");
 namespace
 {
 const int CARD_VIEW_GAP_VERT  = 24; // pixels
@@ -51,10 +51,10 @@
 }
 
 // This is so we can access some protected members in scrollview.
-class LensScrollView: public nux::ScrollView
+class ScopeScrollView: public nux::ScrollView
 {
 public:
-  LensScrollView(nux::VScrollBar* scroll_bar, NUX_FILE_LINE_DECL)
+  ScopeScrollView(nux::VScrollBar* scroll_bar, NUX_FILE_LINE_DECL)
     : nux::ScrollView(NUX_FILE_LINE_PARAM)
     , right_area_(nullptr)
     , up_area_(nullptr)
@@ -146,37 +146,36 @@
 };
 
 
-NUX_IMPLEMENT_OBJECT_TYPE(LensView);
+NUX_IMPLEMENT_OBJECT_TYPE(ScopeView);
 
-LensView::LensView(Lens::Ptr lens, nux::Area* show_filters)
-  : nux::View(NUX_TRACKER_LOCATION)
-  , filters_expanded(false)
-  , can_refine_search(false)
-  , lens_(lens)
-  , initial_activation_(true)
-  , no_results_active_(false)
-  , last_expanded_group_(nullptr)
-  , last_good_filter_model_(-1)
-  , filter_expansion_pushed_(false)
+ScopeView::ScopeView(Scope::Ptr scope, nux::Area* show_filters)
+: nux::View(NUX_TRACKER_LOCATION)
+, filters_expanded(false)
+, can_refine_search(false)
+, scope_(scope)
+, cancellable_(g_cancellable_new())
+, initial_activation_(true)
+, no_results_active_(false)
+, last_expanded_group_(nullptr)
+, last_good_filter_model_(-1)
+, filter_expansion_pushed_(false)
 {
   SetupViews(show_filters);
   SetupCategories();
   SetupResults();
   SetupFilters();
 
-  dash::Style::Instance().columns_changed.connect(sigc::mem_fun(this, &LensView::OnColumnsChanged));
+  dash::Style::Instance().columns_changed.connect(sigc::mem_fun(this, &ScopeView::OnColumnsChanged));
 
-  search_string.SetGetterFunction(sigc::mem_fun(this, &LensView::get_search_string));
-  filters_expanded.changed.connect(sigc::mem_fun(this, &LensView::OnLensFilterExpanded));
-  view_type.changed.connect(sigc::mem_fun(this, &LensView::OnViewTypeChanged));
-  if (lens_)
+  search_string.SetGetterFunction(sigc::mem_fun(this, &ScopeView::get_search_string));
+  filters_expanded.changed.connect(sigc::mem_fun(this, &ScopeView::OnScopeFilterExpanded));
+  view_type.changed.connect(sigc::mem_fun(this, &ScopeView::OnViewTypeChanged));
+  if (scope_)
   {
-    lens_->connected.changed.connect([&](bool is_connected)
-    {
+    scope_->connected.changed.connect([&](bool is_connected) {
       if (is_connected)
         initial_activation_ = true;
     });
-    lens_->categories_reordered.connect(sigc::mem_fun(this, &LensView::OnCategoryOrderChanged));
   }
 
   ubus_manager_.RegisterInterest(UBUS_RESULT_VIEW_KEYNAV_CHANGED, [&] (GVariant* data) {
@@ -209,17 +208,28 @@
   OnVisibleChanged.connect([&] (nux::Area* area, bool visible) {
     scroll_view_->SetVisible(visible);
   });
-
-}
-
-void LensView::SetupViews(nux::Area* show_filters)
+}
+
+ScopeView::~ScopeView()
+{
+  result_added_connection.disconnect();
+  result_removed_connection.disconnect();
+  category_added_connection.disconnect();
+  category_removed_connection.disconnect();
+  filter_added_connection.disconnect();
+  filter_removed_connection.disconnect();
+
+  g_cancellable_cancel(cancellable_);
+}
+
+void ScopeView::SetupViews(nux::Area* show_filters)
 {
   dash::Style& style = dash::Style::Instance();
 
   layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
-  layout_->SetSpaceBetweenChildren(style.GetSpaceBetweenLensAndFilters());
+  layout_->SetSpaceBetweenChildren(style.GetSpaceBetweenScopeAndFilters());
 
-  scroll_view_ = new LensScrollView(new PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION),
+  scroll_view_ = new ScopeScrollView(new PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION),
                                     NUX_TRACKER_LOCATION);
   scroll_view_->EnableVerticalScrollBar(true);
   scroll_view_->EnableHorizontalScrollBar(false);
@@ -239,7 +249,7 @@
   no_results_->SetVisible(false);
   scroll_layout_->AddView(no_results_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_MATCHCONTENT);
 
-  fscroll_view_ = new LensScrollView(new PlacesVScrollBar(NUX_TRACKER_LOCATION), NUX_TRACKER_LOCATION);
+  fscroll_view_ = new ScopeScrollView(new PlacesVScrollBar(NUX_TRACKER_LOCATION), NUX_TRACKER_LOCATION);
   fscroll_view_->EnableVerticalScrollBar(true);
   fscroll_view_->EnableHorizontalScrollBar(false);
   fscroll_view_->SetVisible(false);
@@ -264,35 +274,48 @@
   SetLayout(layout_);
 }
 
-void LensView::SetupCategories()
+void ScopeView::SetupCategories()
 {
-  if (!lens_)
+  if (!scope_)
     return;
 
-  Categories::Ptr categories = lens_->categories;
-  categories->category_added.connect(sigc::mem_fun(this, &LensView::OnCategoryAdded));
-
-  for (unsigned int i = 0; i < categories->count(); ++i)
-    OnCategoryAdded(categories->RowAtIndex(i));
+  Categories::Ptr categories = scope_->categories;
+  category_added_connection = categories->category_added.connect(sigc::mem_fun(this, &ScopeView::OnCategoryAdded));
+  category_removed_connection = categories->category_removed.connect(sigc::mem_fun(this, &ScopeView::OnCategoryRemoved));
+
+  auto resync_categories = [categories, this] (glib::Object<DeeModel> model)
+  {
+    ClearCategories();
+    for (unsigned int i = 0; i < categories->count(); ++i)
+      OnCategoryAdded(categories->RowAtIndex(i));
+  };
+
+  categories->model.changed.connect(resync_categories);
+  resync_categories(categories->model());
+
+  scope_->category_order.changed.connect([this](std::vector<int> const& category_order) {
+    LOG_DEBUG(logger) << scope_->id() << ": category order changed";
+  });
 }
 
-void LensView::SetupResults()
+void ScopeView::SetupResults()
 {
-  if (!lens_)
+  if (!scope_)
     return;
 
-  Results::Ptr results = lens_->results;
-  results->result_added.connect(sigc::mem_fun(this, &LensView::OnResultAdded));
-  results->result_removed.connect(sigc::mem_fun(this, &LensView::OnResultRemoved));
+  Results::Ptr results = scope_->results;
+  result_added_connection = results->result_added.connect(sigc::mem_fun(this, &ScopeView::OnResultAdded));
+  result_added_connection = results->result_removed.connect(sigc::mem_fun(this, &ScopeView::OnResultRemoved));
 
   results->model.changed.connect([this] (glib::Object<DeeModel> model)
   {
     for (unsigned int i = 0; i < categories_.size(); ++i)
     {
       ResultViewGrid* grid = GetGridForCategory(i);
-      glib::Object<DeeModel> filter_model(lens_->GetFilterModelForCategory(i));
-      Results::Ptr results_model = lens_->results;
-      grid->SetModel(filter_model, results_model->GetTag());
+      if (grid)
+      {
+        grid->SetResultsModel(scope_->GetResultsForCategory(i));
+      }
     }
   });
 
@@ -300,20 +323,31 @@
     OnResultAdded(results->RowAtIndex(i));
 }
 
-void LensView::SetupFilters()
+void ScopeView::SetupFilters()
 {
-  if (!lens_)
+  if (!scope_)
     return;
 
-  Filters::Ptr filters = lens_->filters;
-  filters->filter_added.connect(sigc::mem_fun(this, &LensView::OnFilterAdded));
-  filters->filter_removed.connect(sigc::mem_fun(this, &LensView::OnFilterRemoved));
-
-  for (unsigned int i = 0; i < filters->count(); ++i)
-    OnFilterAdded(filters->FilterAtIndex(i));
+  Filters::Ptr filters = scope_->filters;
+  filter_added_connection = filters->filter_added.connect(sigc::mem_fun(this, &ScopeView::OnFilterAdded));
+  filter_removed_connection = filters->filter_removed.connect(sigc::mem_fun(this, &ScopeView::OnFilterRemoved));
+
+  auto resync_filters = [filters, this] (glib::Object<DeeModel> model)
+  {
+    bool blocked = filter_added_connection.block(true);
+
+    filter_bar_->ClearFilters();
+    for (unsigned int i = 0; i < filters->count(); ++i)
+      OnFilterAdded(filters->FilterAtIndex(i));
+
+    filter_added_connection.block(blocked);
+  };
+
+  filters->model.changed.connect(resync_filters);
+  resync_filters(filters->model());
 }
 
-void LensView::OnCategoryAdded(Category const& category)
+void ScopeView::OnCategoryAdded(Category const& category)
 {
   std::string name = category.name;
   std::string icon_hint = category.icon_hint;
@@ -328,10 +362,11 @@
 
   if (index < categories_.size())
   {
-    // the lens might have restarted and we don't want to create
+    // the scope might have restarted and we don't want to create
     // new PlacesGroup if we can reuse the old one
     PlacesGroup* existing_group = categories_.at(index);
-    if (existing_group->GetCategoryIndex() == index) return;
+    if (existing_group->GetCategoryIndex() == index)
+      return;
   }
 
   PlacesGroup* group = CreatePlacesGroup();
@@ -341,7 +376,7 @@
   group->SetCategoryIndex(index);
   group->SetExpanded(false);
   group->SetVisible(false);
-  group->expanded.connect(sigc::mem_fun(this, &LensView::OnGroupExpanded));
+  group->expanded.connect(sigc::mem_fun(this, &ScopeView::OnGroupExpanded));
 
   reset_filter_models = index < categories_.size();
   /* Add the group at the correct offset into the categories vector */
@@ -375,9 +410,9 @@
   }
   group->SetChildView(grid);
 
-  if (lens_)
+  if (scope_)
   {
-    std::string unique_id = name + lens_->name();
+    std::string unique_id = name + scope_->name();
     grid->unique_id = unique_id;
     grid->expanded = false;
 
@@ -389,24 +424,21 @@
       {
         case ResultView::ActivateType::DIRECT:
         {
-          lens_->Activate(uri);
+          scope_->Activate(uri, nullptr, cancellable_);
         } break;
         case ResultView::ActivateType::PREVIEW:
         {
-          lens_->Preview(uri);
+          scope_->Preview(uri, nullptr, cancellable_);
         } break;
         default: break;
       };
     });
 
-
     /* Set up filter model for this category */
-    Results::Ptr results_model = lens_->results;
-    if (results_model->model())
-    {
-      glib::Object<DeeModel> filter_model(lens_->GetFilterModelForCategory(index));
-      grid->SetModel(filter_model, results_model->GetTag());
-    }
+    Results::Ptr results_model = scope_->GetResultsForCategory(index);
+    counts_[group] = results_model ? results_model->count() : 0;
+
+    grid->SetResultsModel(results_model);
 
     if (reset_filter_models)
     {
@@ -416,7 +448,7 @@
       for (auto it = categories_.begin() + (index + 1); it != categories_.end(); ++it)
       {
         grid = static_cast<ResultViewGrid*>((*it)->GetChildView());
-        grid->SetModel(glib::Object<DeeModel>(), NULL);
+        grid->SetResultsModel(Results::Ptr());
       }
 
       if (static_cast<int>(index) < last_good_filter_model_ || last_good_filter_model_ < 0)
@@ -425,7 +457,7 @@
       }
       if (!fix_filter_models_idle_)
       {
-        fix_filter_models_idle_.reset(new glib::Idle(sigc::mem_fun(this, &LensView::ReinitializeFilterModels), glib::Source::Priority::HIGH));
+        fix_filter_models_idle_.reset(new glib::Idle(sigc::mem_fun(this, &ScopeView::ReinitializeFilterModels), glib::Source::Priority::HIGH));
       }
     }
   }
@@ -435,50 +467,59 @@
   scroll_layout_->AddView(group, 0, nux::MinorDimensionPosition::MINOR_POSITION_START,
                           nux::MinorDimensionSize::MINOR_SIZE_FULL, 100.0f,
                           (nux::LayoutPosition)index);
-}
-
-void LensView::OnCategoryOrderChanged()
-{
-  LOG_DEBUG(logger) << "Reordering categories for " << lens_->name();
-
-  // need references so that the Layout doesn't destroy the views
-  std::vector<nux::ObjectPtr<PlacesGroup> > child_views;
-  for (unsigned i = 0; i < categories_.size(); i++)
-  {
-    child_views.push_back(nux::ObjectPtr<PlacesGroup>(categories_.at(i)));
-    scroll_layout_->RemoveChildObject(categories_.at(i));
-  }
-
-  if (lens_)
-  {
-    // there should be ~10 categories, so this shouldn't be too big of a deal
-    std::vector<unsigned> order(lens_->GetCategoriesOrder());
-    for (unsigned i = 0; i < order.size(); i++)
-    {
-      unsigned desired_category_index = order[i];
-      for (unsigned j = 0; j < child_views.size(); j++)
-      {
-        if (child_views[j]->GetCategoryIndex() == desired_category_index)
-        {
-          scroll_layout_->AddView(child_views[j].GetPointer(), 0);
-          break;
-        }
-      }
-    }
-  }
-}
-
-bool LensView::ReinitializeFilterModels()
-{
-  if (!lens_)
+
+  UpdateCounts(group);
+}
+
+void ScopeView::OnCategoryRemoved(Category const& category)
+{
+  std::string name = category.name;
+  std::string icon_hint = category.icon_hint;
+  std::string renderer_name = category.renderer_name;
+  unsigned index = (category.index == unsigned(-1)) ? categories_.size() : category.index;
+
+  LOG_DEBUG(logger) << "Category removed: " << name
+                    << "(" << icon_hint
+                    << ", " << renderer_name
+                    << ", " << boost::lexical_cast<int>(index) << ")";
+
+  if (index >= categories_.size())
+    return;
+
+  auto category_position = categories_.begin() + index;
+  PlacesGroup* existing_group = *category_position;
+  categories_.erase(category_position);
+  counts_.erase(existing_group);
+
+  RemoveChild(existing_group);
+  scroll_layout_->RemoveChildObject(existing_group);
+  QueueRelayout();
+}
+
+void ScopeView::ClearCategories()
+{
+  for (auto category_position = categories_.begin(), end = categories_.end(); category_position != end; ++category_position)
+  {
+    PlacesGroup* group = *category_position;
+    RemoveChild(group);
+    scroll_layout_->RemoveChildObject(group);
+  }
+  counts_.clear();
+  categories_.clear();
+  QueueRelayout();
+}
+
+bool ScopeView::ReinitializeFilterModels()
+{
+  if (!scope_)
     return false;
 
-  Results::Ptr results_model = lens_->results;
+  Results::Ptr results_model = scope_->results;
   for (unsigned i = last_good_filter_model_ + 1; i < categories_.size(); ++i)
   {
     ResultViewGrid* grid = GetGridForCategory(i);
-    glib::Object<DeeModel> filter_model(lens_->GetFilterModelForCategory(i));
-    grid->SetModel(filter_model, results_model->GetTag());
+    if (grid)
+      grid->SetResultsModel(scope_->GetResultsForCategory(i));
   }
 
   last_good_filter_model_ = -1;
@@ -486,21 +527,21 @@
   return false;
 }
 
-ResultViewGrid* LensView::GetGridForCategory(unsigned category_index)
+ResultViewGrid* ScopeView::GetGridForCategory(unsigned category_index)
 {
   if (category_index >= categories_.size()) return nullptr;
   PlacesGroup* group = categories_.at(category_index);
   return static_cast<ResultViewGrid*>(group->GetChildView());
 }
 
-ResultView* LensView::GetResultViewForCategory(unsigned category_index)
+ResultView* ScopeView::GetResultViewForCategory(unsigned category_index)