Merge lp:~unity-team/unity/libunity-7.0-breakage into lp:unity

[Nick Dedekind]

.

[Michal Hruby (mhr3)]

1341 + g_variant_builder_add(&b, "v", g_variant_ref(v));

AFAICT, the variant_ref is causing a leak, should be just "(GVariant*)v".

2595 + variants[i] = g_variant_ref(columns[i]);

And another leak.

3503 + return result != NULL ? result : ""84;

84?

3564 + gchar* key = g_strdup(it->first.c_str());
3565 + GVariant* ptr = g_variant_ref(it->second);

Nope, nope, don't dup, don't ref, VariantBuilder will do that itself.

3698 + gint32 GetInt32() const;
3699 + guint32 GetUInt32() const;
3700 + gint64 GetInt64() const;
3701 + guint64 GetUInt64() const;

IIRC, the idea here was that UnityCore doesn't expose any glib types to the consumers.

Otherwise looking good from my point of view.

[Michal Hruby (mhr3)]

3589 + g_hash_table_insert(hash_table, g_strdup(it->first.c_str()), it->second);

Here you actually do need to ref the variant, since you setup the hashtable to unref it on destruction. :)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-04-03 20:28:58 +0000
+++ CMakeLists.txt	2013-05-15 21:06:29 +0000
@@ -54,6 +54,8 @@
 
 if (CMAKE_BUILD_TYPE MATCHES coverage)
   set (COVERAGE_XML_FILE "${CMAKE_BINARY_DIR}/coverage.xml")
+  set (COVERAGE_INFO_FILE "${CMAKE_BINARY_DIR}/coverage-html.info")
+  set (COVERAGE_HTML_DIR "${CMAKE_BINARY_DIR}/coverage-html")
 
   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage" )
   set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage" )
@@ -68,6 +70,20 @@
       add_custom_target (coverage-xml 
           COMMAND  "${GCOVR_EXECUTABLE}" --exclude="tests.*" --exclude="obj-.*" -x -r "${CMAKE_SOURCE_DIR}" -o "${COVERAGE_XML_FILE}")
   endif()
+
+  find_program(LCOV_EXECUTABLE lcov HINTS ${LCOV_ROOT} "${LCOV_ROOT}/bin")
+  find_program(GENHTML_EXECUTABLE genhtml HINTS ${GENHTML_ROOT} "${GENHTML_ROOT}/bin")
+  if (NOT LCOV_EXECUTABLE)
+      message(FATAL_ERROR "Cannot enable coverage targets because gcovr was not found.")
+  elseif (NOT GENHTML_EXECUTABLE)
+      message(FATAL_ERROR "Cannot enable coverage targets because genhtml was not found.")
+  else ()
+      message (STATUS "Enabling HTML coverage report")
+      add_custom_target (coverage-html 
+          COMMAND "${LCOV_EXECUTABLE}" --directory "${CMAKE_BINARY_DIR}" --capture --output-file "${COVERAGE_INFO_FILE}"
+          COMMAND "${GENHTML_EXECUTABLE}" --output-directory "${COVERAGE_HTML_DIR}" "${COVERAGE_INFO_FILE}")
+  endif()
+
 endif (CMAKE_BUILD_TYPE MATCHES coverage)
 
 
@@ -130,7 +146,7 @@
 #
 set (PREFIXDIR "${CMAKE_INSTALL_PREFIX}")
 set (DATADIR "${CMAKE_INSTALL_PREFIX}/share")
-set (PKGDATADIR "${DATADIR}/unity/${UNITY_COMPONENTS_VERSION}")
+set (PKGDATADIR "${DATADIR}/unity/icons")
 set (GETTEXT_PACKAGE "unity")
 set (LOCALE_DIR "${DATADIR}/locale")
 set (VERSION "${UNITY_VERSION}")
@@ -204,7 +220,7 @@
     libbamf3>=0.4.0
     libnotify
     libstartup-notification-1.0
-    nux-4.0>=4.0.0
+    nux-4.0>=4.0.1
     sigc++-2.0
     unity-misc>=0.4.0
     zeitgeist-1.0>=0.3.18

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2013-03-04 16:24:20 +0000
+++ UnityCore/CMakeLists.txt	2013-05-15 21:06:29 +0000
@@ -4,7 +4,6 @@
     dee-1.0
     sigc++-2.0
     nux-core-4.0
-    gdk-pixbuf-2.0
     unity-protocol-private
 )
 pkg_check_modules (CORE_DEPS REQUIRED ${UNITY_CORE_DEPS})
@@ -21,7 +20,6 @@
      CheckOptionFilter.h
      DBusIndicators.h
      DesktopUtilities.h
-     FilesystemLenses.h
      Filter.h
      Filters.h
      GenericPreview.h
@@ -33,27 +31,32 @@
      GLibWrapper.h
      GLibWrapper-inl.h
      GnomeSessionManager.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
      Model.h
      Model-inl.h
+     ModelIterator.h
      ModelRowAdaptor.h
      ModelRowAdaptor-inl.h
+     PaymentPreview.h
      Preview.h
+     PreviewPlayer.h
      RadioOptionFilter.h
      RatingsFilter.h
      Result.h
-     ResultIterator.h
      Results.h
-     SeriesPreview.h
+     Scope.h
+     ScopeData.h
+     Scopes.h
+     ScopeProxy.h
+     ScopeProxyInterface.h
      SessionManager.h
      SocialPreview.h
      Track.h
@@ -69,7 +72,6 @@
      CheckOptionFilter.cpp
      DBusIndicators.cpp
      DesktopUtilities.cpp
-     FilesystemLenses.cpp
      Filter.cpp
      Filters.cpp
      GenericPreview.cpp
@@ -79,23 +81,26 @@
      GLibSource.cpp
      GLibWrapper.cpp
      GnomeSessionManager.cpp
+     GSettingsScopes.cpp
      Hud.cpp
-     HomeLens.cpp
      Indicator.cpp
      IndicatorEntry.cpp
      Indicators.cpp
-     Lens.cpp
      MoviePreview.cpp
      MultiRangeFilter.cpp
      MusicPreview.cpp
      ModelRowAdaptor.cpp
+     PaymentPreview.cpp
      Preview.cpp
+     PreviewPlayer.cpp
      RatingsFilter.cpp
      RadioOptionFilter.cpp
      Result.cpp
-     ResultIterator.cpp
      Results.cpp
-     SeriesPreview.cpp
+     Scope.cpp
+     ScopeData.cpp
+     Scopes.cpp
+     ScopeProxy.cpp
      SocialPreview.cpp
      Track.cpp
      Tracks.cpp

=== modified file 'UnityCore/Categories.cpp'
--- UnityCore/Categories.cpp	2012-03-14 06:24:18 +0000
+++ UnityCore/Categories.cpp	2013-05-15 21:06:29 +0000
@@ -25,6 +25,7 @@
 {
 
 Categories::Categories()
+ : Categories(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-05-15 21:06: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-05-15 21:06: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/CheckOptionFilter.cpp'
--- UnityCore/CheckOptionFilter.cpp	2012-10-29 09:34:54 +0000
+++ UnityCore/CheckOptionFilter.cpp	2013-05-15 21:06:29 +0000
@@ -28,9 +28,11 @@
 DECLARE_LOGGER(logger, "unity.dash.filter.checkoption");
 
 CheckOptionFilter::CheckOptionFilter(DeeModel* model, DeeModelIter* iter)
-  : Filter(model, iter)
+: Filter(model, iter)
+, show_all_button_(true)
 {
   options.SetGetterFunction(sigc::mem_fun(this, &CheckOptionFilter::get_options));
+  show_all_button.SetGetterFunction(sigc::mem_fun(this, &CheckOptionFilter::get_show_all_button));
   Refresh();
 }
 
@@ -41,7 +43,16 @@
 }
 
 void CheckOptionFilter::Update(Filter::Hints& hints)
-{
+{  
+  GVariant* show_all_button_variant = hints["show-all-button"];
+  if (show_all_button_variant)
+  {
+    bool tmp_show = show_all_button_;
+    g_variant_get(show_all_button_variant, "b", &show_all_button_);
+    if (tmp_show != show_all_button_)
+      show_all_button.EmitChanged(show_all_button_);
+  }
+
   GVariant* options_variant = hints["options"];
   GVariantIter* options_iter;
 
@@ -80,6 +91,11 @@
   return options_;
 }
 
+bool CheckOptionFilter::get_show_all_button() const
+{
+  return show_all_button_;
+}
+
 void CheckOptionFilter::UpdateState()
 {
   if (!IsValid())

=== modified file 'UnityCore/CheckOptionFilter.h'
--- UnityCore/CheckOptionFilter.h	2011-08-05 14:05:37 +0000
+++ UnityCore/CheckOptionFilter.h	2013-05-15 21:06:29 +0000
@@ -39,6 +39,7 @@
   void Clear();
 
   nux::ROProperty<CheckOptions> options;
+  nux::ROProperty<bool> show_all_button;
 
   sigc::signal<void, FilterOption::Ptr> option_added;
   sigc::signal<void, FilterOption::Ptr> option_removed;
@@ -49,10 +50,12 @@
 private:
   void UpdateState();
   CheckOptions const& get_options() const;
+  bool get_show_all_button() const;
   void OptionChanged(bool is_active, std::string const& id);
 
 private:
   CheckOptions options_;
+  bool show_all_button_;
 
 };
 

=== removed file 'UnityCore/FilesystemLenses.cpp'
--- UnityCore/FilesystemLenses.cpp	2013-03-21 19:29:42 +0000
+++ UnityCore/FilesystemLenses.cpp	1970-01-01 00:00:00 +0000
@@ -1,493 +0,0 @@
-// -*- 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]>
- */
-
-#include "FilesystemLenses.h"
-
-#include <stdexcept>
-#include <vector>
-
-#include <gio/gio.h>
-#include <glib.h>
-
-#include <boost/lexical_cast.hpp>
-#include <NuxCore/Logger.h>
-
-#include "config.h"
-#include "GLibWrapper.h"
-#include "GLibSource.h"
-
-
-namespace unity
-{
-namespace dash
-{
-DECLARE_LOGGER(logger, "unity.dash.lens.filesystem");
-
-namespace
-{
-const char* GROUP = "Lens";
-}
-
-// Loads data from a Lens key-file in a usable form
-LensDirectoryReader::LensFileData::LensFileData(GKeyFile* file,
-                                                const gchar *lens_id)
-  : id(g_strdup(lens_id))
-  , domain(g_key_file_get_string(file, G_KEY_FILE_DESKTOP_GROUP, "X-Ubuntu-Gettext-Domain", NULL))
-  , dbus_name(g_key_file_get_string(file, GROUP, "DBusName", NULL))
-  , dbus_path(g_key_file_get_string(file, GROUP, "DBusPath", NULL))
-  , name(g_strdup(g_dgettext(domain.Value(), glib::String(g_key_file_get_string(file, GROUP, "Name", NULL)))))
-  , icon(g_key_file_get_string(file, GROUP, "Icon", NULL))
-  , description(g_key_file_get_locale_string(file, GROUP, "Description", NULL, NULL))
-  , search_hint(g_key_file_get_locale_string(file, GROUP, "SearchHint", NULL, NULL))
-  , visible(true)
-  , shortcut(g_key_file_get_string(file, GROUP, "Shortcut", NULL))
-{
-  if (g_key_file_has_key(file, GROUP, "Visible", NULL))
-  {
-    visible = g_key_file_get_boolean(file, GROUP, "Visible", NULL) != FALSE;
-  }
-}
-
-bool LensDirectoryReader::LensFileData::IsValid(GKeyFile* file, glib::Error& error)
-{
-  return (g_key_file_has_group(file, GROUP) &&
-          g_key_file_has_key(file, GROUP, "DBusName", &error) &&
-          g_key_file_has_key(file, GROUP, "DBusPath", &error) &&
-          g_key_file_has_key(file, GROUP, "Name", &error) &&
-          g_key_file_has_key(file, GROUP, "Icon", &error));
-}
-
-/* A quick guide to finding Lens files
- *
- * We search one or multiple directories looking for folders with the following
- * layout (e.g. is for standard /usr/ installation):
- *
- * /usr/share/unity/lenses
- *                        /applications
- *                                     /applications.lens
- *                                     /applications.scope
- *                                     /chromium-webapps.scope
- *                        /files
- *                              /files.lens
- *                              /zeitgiest.scope
- *                              /ubuntuone.scope
- *
- * Etc, etc. We therefore need to enumerate these directories and find our
- * .lens files in them.
- *
- * Another note is that there is a priority system, where we want to let
- * .lens files found "the most local" to the user (say ~/.local/share)
- * override those found system-wide. This is to ease development of Lenses.
- *
- */
-
-class LensDirectoryReader::Impl
-{
-public:
-  typedef std::map<GFile*, glib::Cancellable::Ptr> CancellableMap;
-
-  Impl(LensDirectoryReader *owner, std::string const& directory)
-    : owner_(owner)
-    , directory_(g_file_new_for_path(directory.c_str()))
-    , children_waiting_to_load_(0)
-    , enumeration_done_(false)
-  {
-    LOG_DEBUG(logger) << "Initialising lens reader for: " << directory;
-
-    auto cancellable = std::make_shared<glib::Cancellable>();
-    g_file_enumerate_children_async(directory_,
-                                    G_FILE_ATTRIBUTE_STANDARD_NAME,
-                                    G_FILE_QUERY_INFO_NONE,
-                                    G_PRIORITY_DEFAULT,
-                                    *cancellable,
-                                    (GAsyncReadyCallback)OnDirectoryEnumerated,
-                                    this);
-    cancel_map_[directory_] = cancellable;
-  }
-
-  void EnumerateLensesDirectoryChildren(GFileEnumerator* enumerator);
-  void LoadLensFile(std::string const& lensfile_path);
-  void GetLensDataFromKeyFile(GFile* path, const char* data, gsize length);
-  DataList GetLensData() const;
-  void SortLensList();
-
-  static void OnDirectoryEnumerated(GFile* source, GAsyncResult* res, Impl* self);
-  static void LoadFileContentCallback(GObject* source, GAsyncResult* res, gpointer user_data);
-
-  LensDirectoryReader *owner_;
-  glib::Object<GFile> directory_;
-  DataList lenses_data_;
-  std::size_t children_waiting_to_load_;
-  bool enumeration_done_;
-  CancellableMap cancel_map_;
-};
-
-void LensDirectoryReader::Impl::OnDirectoryEnumerated(GFile* source, GAsyncResult* res, Impl* self)
-{
-  glib::Error error;
-  glib::Object<GFileEnumerator> enumerator(g_file_enumerate_children_finish(source, res, error.AsOutParam()));
-
-  if (error || !enumerator)
-  {
-    glib::String path(g_file_get_path(source));
-    LOG_WARN(logger) << "Unable to enumerate children of directory "
-                     << path << " "
-                     << error;
-    return;
-  }
-  self->cancel_map_.erase(source);
-  self->EnumerateLensesDirectoryChildren(enumerator);
-}
-
-void LensDirectoryReader::Impl::EnumerateLensesDirectoryChildren(GFileEnumerator* in_enumerator)
-{
-  auto cancellable = std::make_shared<glib::Cancellable>();
-  cancel_map_[g_file_enumerator_get_container(in_enumerator)] = cancellable;
-  g_file_enumerator_next_files_async (in_enumerator, 64, G_PRIORITY_DEFAULT,
-                                      *cancellable,
-                                      [] (GObject *src, GAsyncResult *res,
-                                          gpointer data) -> void {
-    // async callback
-    glib::Error error;
-    GFileEnumerator *enumerator = G_FILE_ENUMERATOR (src);
-    // FIXME: won't this kill the enumerator?
-    GList *files = g_file_enumerator_next_files_finish (enumerator, res, error.AsOutParam());
-    if (!error)
-    {
-      Impl *self = (Impl*) data;
-      self->cancel_map_.erase(g_file_enumerator_get_container(enumerator));
-      for (GList *iter = files; iter; iter = iter->next)
-      {
-        glib::Object<GFileInfo> info((GFileInfo*) iter->data);
-
-        std::string name(g_file_info_get_name(info));
-        glib::String dir_path(g_file_get_path(g_file_enumerator_get_container(enumerator)));
-        std::string lensfile_name = name + ".lens";
-
-        glib::String lensfile_path(g_build_filename(dir_path.Value(),
-                                                    name.c_str(),
-                                                    lensfile_name.c_str(),
-                                                    NULL));
-        self->LoadLensFile(lensfile_path.Str());
-      }
-      // the GFileInfos got already freed during the iteration
-      g_list_free (files);
-      self->enumeration_done_ = true;
-    }
-    else
-    {
-      LOG_WARN(logger) << "Cannot enumerate over directory: " << error;
-    }
-  }, this);
-}
-
-void LensDirectoryReader::Impl::LoadLensFile(std::string const& lensfile_path)
-{
-  glib::Object<GFile> file(g_file_new_for_path(lensfile_path.c_str()));
-  auto cancellable = std::make_shared<glib::Cancellable>();
-
-  // How many files are we waiting for to load
-  children_waiting_to_load_++;
-
-  g_file_load_contents_async(file,
-                             *cancellable,
-                             (GAsyncReadyCallback)(LensDirectoryReader::Impl::LoadFileContentCallback),
-                             this);
-  cancel_map_[file] = cancellable;
-}
-
-void LensDirectoryReader::Impl::LoadFileContentCallback(GObject* source,
-                                                        GAsyncResult* res,
-                                                        gpointer user_data)
-{
-  Impl* self = static_cast<Impl*>(user_data);
-  glib::Error error;
-  glib::String contents;
-  gsize length = 0;
-  GFile* file = G_FILE(source);
-  glib::String path(g_file_get_path(file));
-
-  gboolean result = g_file_load_contents_finish(file, res,
-                                                &contents, &length,
-                                                NULL, error.AsOutParam());
-  if (result)
-  {
-    self->GetLensDataFromKeyFile(file, contents.Value(), length);
-    self->SortLensList();
-  }
-  else
-  {
-    LOG_WARN(logger) << "Unable to read lens file "
-                     << path.Str() << ": "
-                     << error;
-    if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-      return; // self is invalid now
-  }
-
-  self->cancel_map_.erase(file);
-
-  // If we're not waiting for any more children to load, signal that we're
-  // done reading the directory
-  self->children_waiting_to_load_--;
-  if (self->children_waiting_to_load_ == 0)
-  {
-    self->owner_->load_finished.emit();
-  }
-}
-
-void LensDirectoryReader::Impl::GetLensDataFromKeyFile(GFile* file,
-                                                       const char* data,
-                                                       gsize length)
-{
-  GKeyFile* key_file = g_key_file_new();
-  glib::String path(g_file_get_path(file));
-  glib::Error error;
-
-  if (g_key_file_load_from_data(key_file, data, length, G_KEY_FILE_NONE, error.AsOutParam()))
-  {
-    if (LensFileData::IsValid(key_file, error))
-    {
-      glib::String id(g_path_get_basename(path.Value()));
-
-      lenses_data_.push_back(LensFileDataPtr(new LensFileData(key_file, id)));
-
-      LOG_DEBUG(logger) << "Sucessfully loaded lens file " << path;
-    }
-    else
-    {
-      LOG_WARN(logger) << "Lens file  "
-                       << path << " is not valid: "
-                       << error;
-    }
-  }
-  else
-  {
-    LOG_WARN(logger) << "Unable to load Lens file "
-                     << path << ": "
-                     << error;
-  }
-  g_key_file_free(key_file);
-}
-
-LensDirectoryReader::DataList LensDirectoryReader::Impl::GetLensData() const
-{
-  return lenses_data_;
-}
-
-void LensDirectoryReader::Impl::SortLensList()
-{
-  //FIXME: We don't have a strict order, but alphabetical serves us well.
-  // When we have an order/policy, please replace this.
-  auto sort_cb = [] (LensFileDataPtr a, LensFileDataPtr b) -> bool
-  {
-    if (a->id.Str() == "applications.lens")
-      return true;
-    else if (b->id.Str() == "applications.lens")
-      return false;
-    else
-      return g_strcmp0(a->id.Value(), b->id.Value()) < 0;
-  };
-  std::sort(lenses_data_.begin(),
-            lenses_data_.end(),
-            sort_cb);
-}
-
-LensDirectoryReader::LensDirectoryReader(std::string const& directory)
-  : pimpl(new Impl(this, directory))
-{
-}
-
-LensDirectoryReader::~LensDirectoryReader()
-{
-  delete pimpl;
-}
-
-LensDirectoryReader::Ptr LensDirectoryReader::GetDefault()
-{
-  static LensDirectoryReader::Ptr main_reader(new LensDirectoryReader(LENSES_DIR));
-
-  return main_reader;
-}
-
-bool LensDirectoryReader::IsDataLoaded() const
-{
-  return pimpl->children_waiting_to_load_ == 0 && pimpl->enumeration_done_;
-}
-
-LensDirectoryReader::DataList LensDirectoryReader::GetLensData() const
-{
-  return pimpl->GetLensData();
-}
-
-class FilesystemLenses::Impl
-{
-public:
-  Impl(FilesystemLenses* owner, LensDirectoryReader::Ptr const& reader);
-  ~Impl()
-  {
-    finished_slot_.disconnect();
-  }
-
-  void OnLoadingFinished();
-
-  LensList GetLenses() const;
-  Lens::Ptr GetLens(std::string const& lens_id) const;
-  Lens::Ptr GetLensAtIndex(std::size_t index) const;
-  Lens::Ptr GetLensForShortcut(std::string const& lens_shortcut) const;
-  std::size_t count() const;
-
-  FilesystemLenses* owner_;
-  LensDirectoryReader::Ptr reader_;
-  LensList lenses_;
-  sigc::connection finished_slot_;
-  glib::Source::UniquePtr load_idle_;
-};
-
-FilesystemLenses::Impl::Impl(FilesystemLenses* owner, LensDirectoryReader::Ptr const& reader)
-  : owner_(owner)
-  , reader_(reader)
-{
-  finished_slot_ = reader_->load_finished.connect(sigc::mem_fun(this, &Impl::OnLoadingFinished));
-  if (reader_->IsDataLoaded())
-  {
-    // we won't get any signal, so let's just emit our signals after construction
-    load_idle_.reset(new glib::Idle([&] () {
-      OnLoadingFinished();
-      return false;
-    }, glib::Source::Priority::DEFAULT));
-  }
-}
-
-void FilesystemLenses::Impl::OnLoadingFinished()
-{
-  // FIXME: clear lenses_ first?
-  for (auto lens_data : reader_->GetLensData())
-  {
-    Lens::Ptr lens(new Lens(lens_data->id,
-                            lens_data->dbus_name,
-                            lens_data->dbus_path,
-                            lens_data->name,
-                            lens_data->icon,
-                            lens_data->description,
-                            lens_data->search_hint,
-                            lens_data->visible,
-                            lens_data->shortcut));
-    lenses_.push_back (lens);
-  }
-
-  for (Lens::Ptr& lens: lenses_)
-    owner_->lens_added.emit(lens);
-
-  owner_->lenses_loaded.emit();
-}
-
-Lenses::LensList FilesystemLenses::Impl::GetLenses() const
-{
-  return lenses_;
-}
-
-Lens::Ptr FilesystemLenses::Impl::GetLens(std::string const& lens_id) const
-{
-  for (auto lens: lenses_)
-  {
-    if (lens->id == lens_id)
-    {
-      return lens;
-    }
-  }
-
-  return Lens::Ptr();
-}
-
-Lens::Ptr FilesystemLenses::Impl::GetLensAtIndex(std::size_t index) const
-{
-  try
-  {
-    return lenses_.at(index);
-  }
-  catch (std::out_of_range& error)
-  {
-    LOG_WARN(logger) << error.what();
-  }
-  return Lens::Ptr();
-}
-
-Lens::Ptr FilesystemLenses::Impl::GetLensForShortcut(std::string const& lens_shortcut) const
-{
-  for (auto lens: lenses_)
-  {
-    if (lens->shortcut == lens_shortcut)
-    {
-      return lens;
-    }
-  }
-
-  return Lens::Ptr();
-}
-
-std::size_t FilesystemLenses::Impl::count() const
-{
-  return lenses_.size();
-}
-
-
-FilesystemLenses::FilesystemLenses()
-  : pimpl(new Impl(this, LensDirectoryReader::GetDefault()))
-{
-  Init();
-}
-
-FilesystemLenses::FilesystemLenses(LensDirectoryReader::Ptr const& reader)
-  : pimpl(new Impl(this, reader))
-{
-  Init();
-}
-
-void FilesystemLenses::Init()
-{
-  count.SetGetterFunction(sigc::mem_fun(pimpl, &Impl::count));
-}
-
-FilesystemLenses::~FilesystemLenses()
-{
-  delete pimpl;
-}
-
-Lenses::LensList FilesystemLenses::GetLenses() const
-{
-  return pimpl->GetLenses();
-}
-
-Lens::Ptr FilesystemLenses::GetLens(std::string const& lens_id) const
-{
-  return pimpl->GetLens(lens_id);
-}
-
-Lens::Ptr FilesystemLenses::GetLensAtIndex(std::size_t index) const
-{
-  return pimpl->GetLensAtIndex(index);
-}
-
-Lens::Ptr FilesystemLenses::GetLensForShortcut(std::string const& lens_shortcut) const
-{
-  return pimpl->GetLensForShortcut(lens_shortcut);
-}
-
-}
-}

=== removed file 'UnityCore/FilesystemLenses.h'
--- UnityCore/FilesystemLenses.h	2013-03-12 15:21:19 +0000
+++ UnityCore/FilesystemLenses.h	1970-01-01 00:00:00 +0000
@@ -1,102 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2011-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: Neil Jagdish Patel <[e-mail]>
- */
-
-#ifndef UNITY_FILESYSTEM_LENSES_H
-#define UNITY_FILESYSTEM_LENSES_H
-
-#include <memory>
-#include <sigc++/signal.h>
-#include <sigc++/trackable.h>
-
-#include "Lenses.h"
-
-namespace unity
-{
-namespace dash
-{
-
-class LensDirectoryReader : public sigc::trackable
-{
-public:
-  struct LensFileData
-  {
-    LensFileData(GKeyFile* file, const gchar *lens_id);
-    static bool IsValid(GKeyFile* file, glib::Error& error);
-
-    glib::String id;
-    glib::String domain;
-    glib::String dbus_name;
-    glib::String dbus_path;
-    glib::String name;
-    glib::String icon;
-    glib::String description;
-    glib::String search_hint;
-    bool         visible;
-    glib::String shortcut;
-  };
-
-  typedef std::shared_ptr<LensDirectoryReader> Ptr;
-  typedef std::shared_ptr<LensFileData> LensFileDataPtr;
-  typedef std::vector<LensFileDataPtr> DataList;
-
-  LensDirectoryReader(std::string const& directory);
-  ~LensDirectoryReader();
-
-  static LensDirectoryReader::Ptr GetDefault();
-
-  bool IsDataLoaded() const;
-  DataList GetLensData() const;
-
-  sigc::signal<void> load_finished;
-
-private:
-  class Impl;
-  Impl* pimpl;
-};
-
-// Reads Lens information from the filesystem, as per-specification, and creates
-// Lens instances using this data
-class FilesystemLenses : public Lenses
-{
-public:
-  typedef std::shared_ptr<FilesystemLenses> Ptr;
-
-  FilesystemLenses();
-  FilesystemLenses(LensDirectoryReader::Ptr const& reader);
-
-  ~FilesystemLenses();
-
-  LensList GetLenses() const override;
-  Lens::Ptr GetLens(std::string const& lens_id) const override;
-  Lens::Ptr GetLensAtIndex(std::size_t index) const override;
-  Lens::Ptr GetLensForShortcut(std::string const& lens_shortcut) const override;
-
-  sigc::signal<void> lenses_loaded;
-
-private:
-  void Init();
-
-  class Impl;
-  Impl* pimpl;
-};
-
-}
-}
-
-#endif

=== modified file 'UnityCore/Filter.cpp'
--- UnityCore/Filter.cpp	2012-10-29 09:34:54 +0000
+++ UnityCore/Filter.cpp	2013-05-15 21:06:29 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "Filter.h"
+#include "Filters.h"
 
 #include <NuxCore/Logger.h>
 
@@ -25,6 +26,7 @@
 #include "MultiRangeFilter.h"
 #include "RadioOptionFilter.h"
 #include "RatingsFilter.h"
+#include "GLibWrapper.h"
 
 namespace unity
 {
@@ -41,7 +43,7 @@
 {
   typedef Signal<void, DeeModel*, DeeModelIter*> RowSignalType;
 
-  // If the model is destroyed (say if the lens restarts) then we should handle
+  // If the model is destroyed (say if the scope restarts) then we should handle
   // that gracefully
   g_object_weak_ref(reinterpret_cast<GObject*>(model_),
                     (GWeakNotify)Filter::OnModelDestroyed, this);
@@ -140,67 +142,63 @@
 
 void Filter::HintsToMap(Hints& map)
 {
-  GVariant* row_value = dee_model_get_value(model_, iter_, FilterColumn::RENDERER_STATE);
-
-  GVariantIter iter;
-  g_variant_iter_init(&iter, row_value);
-
-  char* key = NULL;
-  GVariant* value = NULL;
-  while (g_variant_iter_loop(&iter, "{sv}", &key, &value))
-  {
-    map[key] = value;
-  }
-  g_variant_unref(row_value);
+  glib::Variant row_value(dee_model_get_value(model_, iter_, FilterColumn::RENDERER_STATE), glib::StealRef());
+  row_value.ASVToHints(map);
+}
+
+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())
-    return dee_model_get_string(model_, iter_, FilterColumn::ID);
-  return "";
+  return FilterAdaptor(model_, iter_, nullptr).get_id();
 }
 
 std::string Filter::get_name() const
 {
-  if (IsValid())
-    return dee_model_get_string(model_, iter_, FilterColumn::NAME);
-  return "";
+  return FilterAdaptor(model_, iter_, nullptr).get_name();
 }
 
 std::string Filter::get_icon_hint() const
 {
-  if (IsValid())
-    return dee_model_get_string(model_, iter_, FilterColumn::ICON_HINT);
-  return "";
+  return FilterAdaptor(model_, iter_, nullptr).get_icon_hint();
 }
 
 std::string Filter::get_renderer_name() const
 {
-  if (IsValid())
-    return dee_model_get_string(model_, iter_, FilterColumn::RENDERER_NAME);
-  return "";
+  return FilterAdaptor(model_, iter_, nullptr).get_renderer_name();
 }
 
 bool Filter::get_visible() const
 {
-  if (IsValid())
-    return dee_model_get_bool(model_, iter_, FilterColumn::VISIBLE);
-  return false;
+  return FilterAdaptor(model_, iter_, nullptr).get_visible();
 }
 
 bool Filter::get_collapsed() const
 {
-  if (IsValid())
-    return dee_model_get_bool(model_, iter_, FilterColumn::COLLAPSED);
-  return true;
+  return FilterAdaptor(model_, iter_, nullptr).get_collapsed();
 }
 
 bool Filter::get_filtering() const
 {
-  if (IsValid())
-    return dee_model_get_bool(model_, iter_, FilterColumn::FILTERING);
-  return false;
+  return FilterAdaptor(model_, iter_, nullptr).get_filtering();
 }
 
 }

=== modified file 'UnityCore/Filter.h'
--- UnityCore/Filter.h	2012-07-16 11:03:32 +0000
+++ UnityCore/Filter.h	2013-05-15 21:06: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-05-15 21:06:29 +0000
@@ -38,26 +38,82 @@
   renderer_name.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), 3));
 }
 
-DeeModel* FilterAdaptor::model() const
-{
-  return model_;
-}
-
-DeeModelIter* FilterAdaptor::iter() const
-{
-  return iter_;
+std::string FilterAdaptor::get_id() const
+{
+  if (model_ && iter_)
+    return dee_model_get_string(model_, iter_, FilterColumn::ID);
+  return "";
+}
+
+std::string FilterAdaptor::get_name() const
+{
+  if (model_ && iter_)
+    return dee_model_get_string(model_, iter_, FilterColumn::NAME);
+  return "";
+}
+
+std::string FilterAdaptor::get_icon_hint() const
+{
+  if (model_ && iter_)
+    return dee_model_get_string(model_, iter_, FilterColumn::ICON_HINT);
+  return "";
+}
+
+std::string FilterAdaptor::get_renderer_name() const
+{
+  if (model_ && iter_)
+    return dee_model_get_string(model_, iter_, FilterColumn::RENDERER_NAME);
+  return "";
+}
+
+bool FilterAdaptor::get_visible() const
+{
+  if (model_ && iter_)
+    return dee_model_get_bool(model_, iter_, FilterColumn::VISIBLE);
+  return false;
+}
+
+bool FilterAdaptor::get_collapsed() const
+{
+  if (model_ && iter_)
+    return dee_model_get_bool(model_, iter_, FilterColumn::COLLAPSED);
+  return true;
+}
+
+bool FilterAdaptor::get_filtering() const
+{
+  if (model_ && iter_)
+    return dee_model_get_bool(model_, iter_, FilterColumn::FILTERING);
+  return false;
+}
+
+Filter::Ptr FilterAdaptor::create_filter() const
+{
+  return Filter::FilterFromIter(model_, iter_);
+}
+
+void FilterAdaptor::MergeState(glib::HintsMap const& hints)
+{
+  glib::HintsMap current_hints;
+  glib::Variant row_state_value(dee_model_get_value(model_, iter_, FilterColumn::RENDERER_STATE), glib::StealRef());
+  row_state_value.ASVToHints(current_hints);
+
+  for (auto iter = hints.begin(); iter != hints.end(); ++iter)
+  {
+    current_hints[iter->first] = iter->second;
+  }
+
+  dee_model_set_value(model_, iter_, FilterColumn::RENDERER_STATE, glib::Variant::FromHints(current_hints));
 }
 
 
 Filters::Filters()
+: Filters(ModelType::REMOTE)
 {
-  row_added.connect(sigc::mem_fun(this, &Filters::OnRowAdded));
-  row_changed.connect(sigc::mem_fun(this, &Filters::OnRowChanged));
-  row_removed.connect(sigc::mem_fun(this, &Filters::OnRowRemoved));
 }
 
 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,27 +126,91 @@
 Filter::Ptr Filters::FilterAtIndex(std::size_t index)
 {
   FilterAdaptor adaptor = RowAtIndex(index);
-  return filter_map_[adaptor.iter()];
+  if (filter_map_.find(adaptor.get_id()) == filter_map_.end())
+  {
+    OnRowAdded(adaptor);
+  }
+  return filter_map_[adaptor.get_id()];
+}
+
+bool Filters::ApplyStateChanges(glib::Variant const& filter_rows)
+{
+  if (!filter_rows)
+    return false;
+
+  if (!g_variant_is_of_type (filter_rows, G_VARIANT_TYPE ("a(ssssa{sv}bbb)")))
+  {
+    return false;
+  }
+
+  gchar* id = nullptr;
+  gchar* name = nullptr;
+  gchar* icon_hint = nullptr;
+  gchar* renderer_name = nullptr;
+  GVariant* hints = nullptr;
+  gboolean visible;
+  gboolean collapsed;
+  gboolean filtering;
+
+  GVariantIter iter;
+  g_variant_iter_init(&iter, filter_rows);
+  while (g_variant_iter_loop(&iter, "(ssss@a{sv}bbb)", &id,
+                                                       &name,
+                                                       &icon_hint,
+                                                       &renderer_name,
+                                                       &hints,
+                                                       &visible,
+                                                       &collapsed,
+                                                       &filtering))
+  {
+    for (FilterAdaptorIterator it(begin()); !it.IsLast(); ++it)
+    {
+      FilterAdaptor filter_adaptor = *it;
+
+      if (id && filter_adaptor.get_id().compare(id) == 0)
+      {
+        glib::HintsMap hints_map;
+        if (glib::Variant(hints).ASVToHints(hints_map))
+        {
+          filter_adaptor.MergeState(hints_map);
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+FilterAdaptorIterator Filters::begin() const
+{
+  return FilterAdaptorIterator(model(), dee_model_get_first_iter(model()), GetTag());
+
+}
+
+FilterAdaptorIterator Filters::end() const
+{
+  return FilterAdaptorIterator(model(), dee_model_get_last_iter(model()), GetTag());  
 }
 
 void Filters::OnRowAdded(FilterAdaptor& filter)
 {
-  Filter::Ptr ret = Filter::FilterFromIter(filter.model(), filter.iter());
+  Filter::Ptr ret = filter.create_filter();
 
-  filter_map_[filter.iter()] = ret;
+  filter_map_[filter.get_id()] = ret;
   filter_added(ret);
 }
 
 void Filters::OnRowChanged(FilterAdaptor& filter)
 {
-  filter_changed(filter_map_[filter.iter()]);
+  filter_changed(filter_map_[filter.get_id()]);
 }
 
 void Filters::OnRowRemoved(FilterAdaptor& filter)
 {
-  filter_removed(filter_map_[filter.iter()]);
-  filter_map_.erase(filter.iter());
+  filter_removed(filter_map_[filter.get_id()]);
+  filter_map_.erase(filter.get_id());
 }
+
 
 }
 }

=== modified file 'UnityCore/Filters.h'
--- UnityCore/Filters.h	2012-03-14 06:24:18 +0000
+++ UnityCore/Filters.h	2013-05-15 21:06:29 +0000
@@ -24,6 +24,7 @@
 #include <map>
 
 #include "Model.h"
+#include "ModelIterator.h"
 #include "Filter.h"
 
 namespace unity
@@ -39,16 +40,26 @@
 
   nux::ROProperty<std::string> renderer_name;
 
-  DeeModel* model() const;
-  DeeModelIter* iter() const;
+  std::string get_id() const;
+  std::string get_name() const;
+  std::string get_icon_hint() const;
+  std::string get_renderer_name() const;
+  bool get_visible() const;
+  bool get_collapsed() const;
+  bool get_filtering() const;
+
+  Filter::Ptr create_filter() const;
+
+  void MergeState(glib::HintsMap const& hints);
 };
 
+typedef ModelIterator<FilterAdaptor> FilterAdaptorIterator;
 
 class Filters : public Model<FilterAdaptor>
 {
 public:
   typedef std::shared_ptr<Filters> Ptr;
-  typedef std::map<DeeModelIter*, Filter::Ptr> FilterMap;
+  typedef std::map<std::string, Filter::Ptr> FilterMap;
 
   Filters();
   Filters(ModelType model_type);
@@ -60,6 +71,11 @@
   sigc::signal<void, Filter::Ptr> filter_changed;
   sigc::signal<void, Filter::Ptr> filter_removed;
 
+  bool ApplyStateChanges(glib::Variant const& filter_rows);
+
+  FilterAdaptorIterator begin() const;
+  FilterAdaptorIterator end() const;
+
   /* There will be added/changed/removed signals here when we have that working */
 private:
   void OnRowAdded(FilterAdaptor& filter);

=== modified file 'UnityCore/GLibWrapper.cpp'
--- UnityCore/GLibWrapper.cpp	2013-03-21 19:07:11 +0000
+++ UnityCore/GLibWrapper.cpp	2013-05-15 21:06: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	2013-03-21 19:29:25 +0000
+++ UnityCore/GLibWrapper.h	2013-05-15 21:06:29 +0000
@@ -107,6 +107,7 @@
   GError* error_;
 };
 
+// wrapper for raw gcha*. auto-deleted.
 class String : boost::noncopyable
 {
 public:
@@ -127,6 +128,14 @@
   gchar* string_;
 };
 
+inline std::string gchar_to_string(const gchar* str)
+{
+  if (!str)
+    return std::string("");
+  else
+    return std::string(str);
+}
+
 class Cancellable : boost::noncopyable
 {
 public:

=== added file 'UnityCore/GSettingsScopes.cpp'
--- UnityCore/GSettingsScopes.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/GSettingsScopes.cpp	2013-05-15 21:06: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-05-15 21:06: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

=== removed file 'UnityCore/HomeLens.cpp'
--- UnityCore/HomeLens.cpp	2013-03-12 21:53:55 +0000
+++ UnityCore/HomeLens.cpp	1970-01-01 00:00:00 +0000
@@ -1,1254 +0,0 @@
-// -*- 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: Mikkel Kamstrup Erlandsen <[e-mail]>
- *              Michal Hruby <[e-mail]>
- */
-
-#include <glib.h>
-#include <dee-icu.h>
-#include <string>
-#include <stdexcept>
-#include <map>
-#include <set>
-#include <utility>
-#include <algorithm>
-
-#include "GLibSignal.h"
-#include "HomeLens.h"
-#include "Lens.h"
-#include "Model.h"
-
-#include "config.h"
-
-namespace unity
-{
-namespace dash
-{
-DECLARE_LOGGER(logger, "unity.dash.lens.home");
-
-namespace
-{
-const gchar* const HOMELENS_PRIORITY = "unity-homelens-priority";
-const gchar* const HOMELENS_RESULTS_MODEL = "unity-homelens-results-model";
-
-const unsigned RESULTS_NAME_COLUMN = 4;
-const unsigned RESULTS_COMMENT_COLUMN = 5;
-}
-
-/*
- * Helper class that maps category offsets between the merged lens and
- * source lenses. We also use it to merge categories from different lenses
- * with the same display name into the same category.
- *
- * NOTE: The model pointers passed in are expected to be pointers to the
- *       result source models - and not the category source models!
- */
-class HomeLens::CategoryRegistry
-{
-public:
-  CategoryRegistry(HomeLens* owner)
-    : owner_(owner)
-    , next_category_index_ (0) {}
-
-  typedef std::pair<DeeModel*, unsigned> ModelOffsetPair;
-
-  int FindCategoryOffset(DeeModel* model, unsigned int source_cat_index)
-  {
-    ModelOffsetPair key = std::make_pair(model, source_cat_index);
-
-    std::map<ModelOffsetPair, unsigned>::iterator it = reg_category_map_.find(key);
-
-    if (it != reg_category_map_.end())
-      return it->second;
-
-    return -1;
-  }
-
-  int FindCategoryOffset(const gchar* display_name)
-  {
-    std::map<std::string,unsigned int>::iterator i =
-                                      reg_by_display_name_.find(display_name);
-    if (i != reg_by_display_name_.end())
-      return i->second;
-
-    return -1;
-  }
-
-  /* Register a new category */
-  unsigned RegisterCategoryOffset(DeeModel*    model,
-                                  unsigned int source_cat_index,
-                                  const gchar* display_name)
-  {
-    ModelOffsetPair key = std::make_pair(model, source_cat_index);
-    std::map<ModelOffsetPair, unsigned>::iterator it = reg_category_map_.find(key);
-
-    if (it != reg_category_map_.end())
-    {
-      std::string name(display_name ? display_name : "(null)");
-      LOG_ERROR(logger) << "Category '" << name
-        << "' (source index: " << source_cat_index << ") already registered!";
-      return it->second;
-    }
-
-    unsigned target_cat_index;
-    bool target_index_found = false;
-
-    if (display_name != NULL)
-    {
-      std::map<std::string, unsigned>::iterator name_it = reg_by_display_name_.find(display_name);
-      if (name_it != reg_by_display_name_.end())
-      {
-        target_cat_index = name_it->second;
-        target_index_found = true;
-      }
-    }
-
-    if (!target_index_found) target_cat_index = next_category_index_++;
-    reg_category_map_[key] = target_cat_index;
-
-    /* Callers pass a NULL display_name when they already have a category
-     * with the right display registered */
-    if (display_name != NULL)
-    {
-      reg_by_display_name_[display_name] = target_cat_index;
-      LOG_DEBUG(logger) << "Registered category '" << display_name
-                        << "' with source index " << source_cat_index
-                        << " and target " << target_cat_index;
-    }
-    else
-    {
-      LOG_DEBUG(logger) << "Registered category with source index "
-                        << source_cat_index << " and target "
-                        << target_cat_index;
-    }
-
-    return target_cat_index;
-  }
-
-  void UnregisterAllForModel(DeeModel* model)
-  {
-    auto it = reg_category_map_.begin();
-
-    // References and iterators to the erased elements are invalidated. 
-    // Other references and iterators are not affected.
-    while (it != reg_category_map_.end())
-    {
-      if (it->first.first == model)
-        reg_category_map_.erase(it++);
-      else
-        ++it;
-    }
-  }
-
-  void NotifyOrderChanged ()
-  {
-    owner_->categories_reordered();
-  }
-
-private:
-  std::map<std::string,unsigned int> reg_by_display_name_;
-  std::map<ModelOffsetPair, unsigned> reg_category_map_;
-  HomeLens* owner_;
-  unsigned next_category_index_;
-};
-
-/*
- * Helper class that merges a set of DeeModels into one super model
- */
-class HomeLens::ModelMerger : public sigc::trackable
-{
-public:
-  ModelMerger(glib::Object<DeeModel> target);
-  virtual ~ModelMerger();
-
-  virtual void AddSource(Lens::Ptr& owner_lens, glib::Object<DeeModel> source);
-  virtual void RemoveSource(glib::Object<DeeModel> const& old_source);
-
-protected:
-  virtual void OnSourceRowAdded(DeeModel* model, DeeModelIter* iter);
-  virtual void OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter);
-  virtual void OnSourceRowChanged(DeeModel* model, DeeModelIter* iter);
-  void EnsureRowBuf(DeeModel* source);
-
-  /* The merge tag lives on the source models, pointing to the mapped
-   * row in the target model */
-  DeeModelTag* FindSourceToTargetTag(DeeModel* model);
-
-protected:
-  std::map<Lens::Ptr, glib::Object<DeeModel> > sources_by_owner_;
-  glib::SignalManager sig_manager_;
-  GVariant** row_buf_;
-  unsigned int n_cols_;
-  glib::Object<DeeModel> target_;
-  std::map<DeeModel*,DeeModelTag*> source_to_target_tags_;
-};
-
-/*
- * Specialized ModelMerger that takes care merging results models.
- * We need special handling here because rows in each lens' results model
- * specifies an offset into the lens' categories model where the display
- * name of the category is defined.
- *
- * This class converts the offset of the source lens' categories into
- * offsets into the merged category model.
- *
- * Each row added to the target is tagged with a pointer to the Lens instance
- * from which it came
- */
-class HomeLens::ResultsMerger : public ModelMerger
-{
-public:
-  ResultsMerger(glib::Object<DeeModel> target,
-                HomeLens::CategoryRegistry* cat_registry);
-
-protected:
-  void OnSourceRowAdded(DeeModel* model, DeeModelIter* iter);
-  void OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter);
-  void OnSourceRowChanged(DeeModel* model, DeeModelIter* iter);
-
-private:
-  HomeLens::CategoryRegistry* cat_registry_;
-};
-
-/*
- * Specialized ModelMerger that takes care merging category models.
- * We need special handling here because rows in each lens' results model
- * specifies an offset into the lens' categories model where the display
- * name of the category is defined.
- *
- * This class records a map of the offsets from the original source category
- * models to the offsets in the combined categories model.
- */
-class HomeLens::CategoryMerger : public ModelMerger
-{
-public:
-  CategoryMerger(glib::Object<DeeModel> target,
-                 HomeLens::CategoryRegistry* cat_registry,
-                 MergeMode merge_mode);
-
-  void OnSourceRowAdded(DeeModel* model, DeeModelIter* iter);
-  void OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter);
-
-  std::vector<unsigned> GetDefaultOrder();
-  std::string GetLensIdForCategory(unsigned) const;
-  std::map<unsigned, Lens::Ptr> const& GetCategoryToLensMap() const;
-  MergeMode GetMergeMode() const { return merge_mode_; }
-
-protected:
-  void RemoveSource(glib::Object<DeeModel> const& old_source);
-
-private:
-  HomeLens::CategoryRegistry* cat_registry_;
-  MergeMode merge_mode_;
-  std::multimap<unsigned, unsigned, std::greater<unsigned> > category_ordering_;
-  std::map<unsigned, Lens::Ptr> category_to_owner_;
-};
-
-/*
- * Specialized ModelMerger that is reponsible for filters, currently ignores
- * everything.
- */
-class HomeLens::FiltersMerger : public ModelMerger
-{
-public:
-  FiltersMerger(glib::Object<DeeModel> target);
-
-  void OnSourceRowAdded(DeeModel* model, DeeModelIter* iter);
-  void OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter);
-  void OnSourceRowChanged(DeeModel* model, DeeModelIter* iter);
-};
-
-/*
- * Pimpl for HomeLens
- */
-class HomeLens::Impl : public sigc::trackable
-{
-public:
-  Impl(HomeLens* owner, MergeMode merge_mode);
-  ~Impl();
-
-  struct CategorySorter
-  {
-    CategorySorter(std::map<unsigned, unsigned>& results_per_category,
-                   std::map<unsigned, Lens::Ptr> const& category_owner_map)
-      : results_per_category_(results_per_category)
-      , category_to_owner_(category_owner_map)
-    {}
-
-    bool operator() (unsigned cat_a, unsigned cat_b)
-    {
-      bool a_has_personal_content = false;
-      bool b_has_personal_content = false;
-
-      auto it = category_to_owner_.find(cat_a);
-      if (it != category_to_owner_.end() && it->second)
-      {
-        a_has_personal_content = it->second->provides_personal_content();
-      }
-      it = category_to_owner_.find(cat_b);
-      if (it != category_to_owner_.end() && it->second)
-      {
-        b_has_personal_content = it->second->provides_personal_content();
-      }
-
-      unsigned a_results = results_per_category_[cat_a];
-      unsigned b_results = results_per_category_[cat_b];
-
-      // prioritize categories that have private content
-      if (a_has_personal_content != b_has_personal_content)
-      {
-        // personal content results are first unless there are 0 results
-        if (a_has_personal_content && a_results > 0) return true;
-        else if (b_has_personal_content) return !(b_results > 0);
-        return false;
-      }
-
-      return a_results > b_results;
-    }
-
-    private:
-      std::map<unsigned, unsigned>& results_per_category_;
-      std::map<unsigned, Lens::Ptr> const& category_to_owner_;
-  };
-
-  void OnLensAdded(Lens::Ptr& lens);
-  gsize FindLensPriority (Lens::Ptr& lens);
-  void EnsureCategoryAnnotation(Lens::Ptr& lens, DeeModel* results, DeeModel* categories);
-  Lens::Ptr FindLensForUri(std::string const& uri);
-  std::vector<unsigned> GetCategoriesOrder();
-  void LensSearchFinished(Lens::Ptr const& lens);
-  bool ResultsContainVisibleMatch(unsigned category);
-
-  std::string const& last_search_string() const { return last_search_string_; }
-
-  HomeLens* owner_;
-  Lenses::LensList lenses_;
-  HomeLens::CategoryRegistry cat_registry_;
-  HomeLens::ResultsMerger results_merger_;
-  HomeLens::CategoryMerger categories_merger_;
-  HomeLens::FiltersMerger filters_merger_;
-  int running_searches_;
-  bool apps_lens_contains_visible_match;
-  std::string last_search_string_;
-  glib::Object<GSettings> settings_;
-  std::vector<unsigned> cached_categories_order_;
-  std::map<unsigned, glib::Object<DeeModel> > category_filter_models_;
-};
-
-/*
- * IMPLEMENTATION
- */
-
-HomeLens::ModelMerger::ModelMerger(glib::Object<DeeModel> target)
-  : row_buf_(NULL)
-  , n_cols_(0)
-  , target_(target)
-{}
-
-HomeLens::ResultsMerger::ResultsMerger(glib::Object<DeeModel> target,
-                                       CategoryRegistry *cat_registry)
-  : HomeLens::ModelMerger::ModelMerger(target)
-  , cat_registry_(cat_registry)
-{}
-
-HomeLens::CategoryMerger::CategoryMerger(glib::Object<DeeModel> target,
-                                         CategoryRegistry *cat_registry,
-                                         MergeMode merge_mode)
-  : HomeLens::ModelMerger::ModelMerger(target)
-  , cat_registry_(cat_registry)
-  , merge_mode_(merge_mode)
-{}
-
-HomeLens::FiltersMerger::FiltersMerger(glib::Object<DeeModel> target)
-  : HomeLens::ModelMerger::ModelMerger(target)
-{}
-
-HomeLens::ModelMerger::~ModelMerger()
-{
-  if (row_buf_)
-    g_free(row_buf_);
-}
-
-void HomeLens::ModelMerger::AddSource(Lens::Ptr& owner_lens,
-                                      glib::Object<DeeModel> source)
-{
-  typedef glib::Signal<void, DeeModel*, DeeModelIter*> RowSignalType;
-
-  if (!source)
-  {
-    LOG_ERROR(logger) << "Trying to add NULL source to ModelMerger";
-    return;
-  }
-
-  /* We always have just one model per Lens instance, so let's make sure
-   * we're not keeping any dangling model signal connections */
-  std::map<Lens::Ptr, glib::Object<DeeModel> >::iterator it =
-    sources_by_owner_.find(owner_lens);
-  if (it != sources_by_owner_.end())
-  {
-    if (it->second == source)
-      return; // this model was already added
-    RemoveSource(it->second);
-  }
-  sources_by_owner_[owner_lens] = source;
-
-  DeeModelTag* merger_tag = dee_model_register_tag(source, NULL);
-  source_to_target_tags_[source.RawPtr()] = merger_tag;
-
-  sig_manager_.Add(new RowSignalType(source.RawPtr(),
-                                     "row-added",
-                                     sigc::mem_fun(this, &HomeLens::ModelMerger::OnSourceRowAdded)));
-
-  sig_manager_.Add(new RowSignalType(source.RawPtr(),
-                                       "row-removed",
-                                       sigc::mem_fun(this, &HomeLens::ModelMerger::OnSourceRowRemoved)));
-
-  sig_manager_.Add(new RowSignalType(source.RawPtr(),
-                                       "row-changed",
-                                       sigc::mem_fun(this, &HomeLens::ModelMerger::OnSourceRowChanged)));
-}
-
-void HomeLens::ModelMerger::RemoveSource(glib::Object<DeeModel> const& source)
-{
-  if (!source)
-  {
-    LOG_ERROR(logger) << "Trying to remove NULL source from ModelMerger";
-    return;
-  }
-
-  sig_manager_.Disconnect(source);
-}
-
-void HomeLens::ModelMerger::OnSourceRowAdded(DeeModel* model, DeeModelIter* iter)
-{
-  // Default impl. does nothing.
-}
-
-void HomeLens::ResultsMerger::OnSourceRowAdded(DeeModel* model, DeeModelIter* iter)
-{
-  DeeModelIter* target_iter;
-  int target_cat_offset, source_cat_offset;
-  const unsigned int CATEGORY_COLUMN = 2;
-
-  EnsureRowBuf(model);
-
-  dee_model_get_row (model, iter, row_buf_);
-
-  /* Update the row with the corrected category offset */
-  source_cat_offset = dee_model_get_uint32(model, iter, CATEGORY_COLUMN);
-  target_cat_offset = cat_registry_->FindCategoryOffset(model, source_cat_offset);
-
-  if (target_cat_offset >= 0)
-  {
-    g_variant_unref (row_buf_[CATEGORY_COLUMN]);
-    row_buf_[CATEGORY_COLUMN] = g_variant_new_uint32(target_cat_offset);
-
-    /* Sink the ref on the new row member. By Dee API contract they must all
-     * be strong refs, not floating */
-    g_variant_ref_sink(row_buf_[CATEGORY_COLUMN]);
-
-    target_iter = dee_model_append_row (target_, row_buf_);
-    DeeModelTag* target_tag = FindSourceToTargetTag(model);
-    dee_model_set_tag(model, iter, target_tag, target_iter);
-
-    LOG_DEBUG(logger) << "Found " << dee_model_get_string(model, iter, 0)
-                      << " (source cat " << source_cat_offset << ", target cat "
-                      << target_cat_offset << ")";
-  }
-  else
-  {
-    LOG_ERROR(logger) << "No category registered for model "
-                      << model << ", source offset " << source_cat_offset
-                      << ": " << dee_model_get_string(model, iter, 0);
-  }
-
-  for (unsigned int i = 0; i < n_cols_; i++) g_variant_unref(row_buf_[i]);
-}
-
-void HomeLens::CategoryMerger::OnSourceRowAdded(DeeModel* model, DeeModelIter* iter)
-{
-  DeeModel* results_model;
-  DeeModelIter* target_iter;
-  DeeModelTag*  target_tag;
-  const gchar* display_name;
-  const unsigned int DISPLAY_NAME_COLUMN = 0;
-  std::string lens_name("Unknown");
-
-  EnsureRowBuf(model);
-
-  results_model = static_cast<DeeModel*>(g_object_get_data(
-                              G_OBJECT(model), HOMELENS_RESULTS_MODEL));
-  if (results_model == NULL)
-  {
-    LOG_DEBUG(logger) << "Category model " << model
-                      << " does not have a results model yet";
-    return;
-  }
-
-  target_tag = FindSourceToTargetTag(model);
-  unsigned source_cat_offset = dee_model_get_position(model, iter);
-
-  Lens::Ptr owner_lens;
-  for (auto it = sources_by_owner_.begin(); it != sources_by_owner_.end(); ++it)
-  {
-    if (it->second == model)
-    {
-      owner_lens = it->first;
-      break;
-    }
-  }
-
-  if (merge_mode_ == MergeMode::OWNER_LENS)
-  {
-    if (owner_lens) lens_name = owner_lens->name();
-    display_name = lens_name.c_str();
-  }
-  else
-  {
-    display_name = dee_model_get_string(model, iter, DISPLAY_NAME_COLUMN);
-  }
-
-  /* If we already have a category registered with the same display name
-   * then we just use that. Otherwise register a new category for it */
-  if (cat_registry_->FindCategoryOffset(display_name) >= 0)
-  {
-    /* Make sure the <results_model, source_cat_offset> pair is registered */
-    cat_registry_->RegisterCategoryOffset(results_model, source_cat_offset,
-                                          display_name);
-    return;
-  }
-
-  /*
-   * Below we can assume that we have a genuinely new category.
-   */
-
-  /* Add the row to the merged categories model and store required metadata */
-  dee_model_get_row(model, iter, row_buf_);
-
-  /* Rename the category */
-  g_variant_unref(row_buf_[DISPLAY_NAME_COLUMN]);
-  row_buf_[DISPLAY_NAME_COLUMN] = g_variant_new_string(display_name);
-  // need to ref sink the floating variant
-  g_variant_ref_sink(row_buf_[DISPLAY_NAME_COLUMN]);
-
-  target_iter = dee_model_append_row(target_, row_buf_);
-  dee_model_set_tag(model, iter, target_tag, target_iter);
-  unsigned target_cat_index = 
-    cat_registry_->RegisterCategoryOffset(results_model, source_cat_offset,
-                                          display_name);
-
-  if (owner_lens) category_to_owner_[target_cat_index] = owner_lens;
-
-  // ensure priorities are taken into account, so default order works
-  gsize lens_priority = GPOINTER_TO_SIZE(g_object_get_data(
-                                   G_OBJECT(model), HOMELENS_PRIORITY));
-  unsigned lens_prio = static_cast<unsigned>(lens_priority);
-  category_ordering_.insert(std::pair<unsigned, unsigned>(lens_prio, target_cat_index));
-  if (category_ordering_.rbegin()->second != target_cat_index)
-  {
-    cat_registry_->NotifyOrderChanged();
-  }
-
-  for (unsigned int i = 0; i < n_cols_; i++) g_variant_unref(row_buf_[i]);
-}
-
-void HomeLens::FiltersMerger::OnSourceRowAdded(DeeModel* model, DeeModelIter* iter)
-{
-  /* Supporting filters on the home screen is possible, but *quite* tricky.
-   * So... Discard ALL the rows!
-   */
-}
-
-void HomeLens::CategoryMerger::OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter)
-{
-  /* We don't support removals of categories.
-   * You can check out any time you like, but you can never leave
-   *
-   * The category registry code is spaghettified enough already.
-   * No more please.
-   */
-  LOG_DEBUG(logger) << "Removal of categories not supported.";
-}
-
-void HomeLens::ModelMerger::OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter)
-{
-  DeeModelIter* target_iter;
-  DeeModelTag*  target_tag;
-
-  EnsureRowBuf(model);
-
-  target_tag = FindSourceToTargetTag(model);
-  target_iter = static_cast<DeeModelIter*>(dee_model_get_tag(model,
-                                                             iter,
-                                                             target_tag));
-
-  /* We might not have registered a target iter for the row.
-   * This fx. happens if we re-used a category based on display_name */
-  if (target_iter != NULL)
-    dee_model_remove(target_, target_iter);
-}
-
-void HomeLens::ResultsMerger::OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter)
-{
-  ModelMerger::OnSourceRowRemoved(model, iter);
-}
-
-void HomeLens::FiltersMerger::OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter)
-{
-  /* We aren't adding any rows to the merged model, so nothing to do here */
-}
-
-void HomeLens::ModelMerger::OnSourceRowChanged(DeeModel* model, DeeModelIter* iter)
-{
-  DeeModelIter* target_iter;
-  DeeModelTag*  target_tag;
-
-  EnsureRowBuf(model);
-
-  dee_model_get_row (model, iter, row_buf_);
-  target_tag = FindSourceToTargetTag(model);
-  target_iter = static_cast<DeeModelIter*>(dee_model_get_tag(model,
-                                                                 iter,
-                                                                 target_tag));
-
-  dee_model_set_row (target_, target_iter, row_buf_);
-
-  for (unsigned int i = 0; i < n_cols_; i++) g_variant_unref(row_buf_[i]);
-}
-
-void HomeLens::ResultsMerger::OnSourceRowChanged(DeeModel* model, DeeModelIter* iter)
-{
-  // FIXME: We can support this, but we need to re-calculate the category offset
-  LOG_WARN(logger) << "In-line changing of results not supported in the home lens. Sorry.";
-}
-
-void HomeLens::FiltersMerger::OnSourceRowChanged(DeeModel* model, DeeModelIter* iter)
-{
-  /* We aren't adding any rows to the merged model, so nothing to do here */
-}
-
-void HomeLens::ModelMerger::EnsureRowBuf(DeeModel* model)
-{
-  if (G_UNLIKELY (n_cols_ == 0))
-  {
-    /* We have two things to accomplish here.
-     * 1) Allocate the row_buf_, and
-     * 2) Make sure that the target model has the correct schema set.
-     *
-     * INVARIANT: n_cols_ == 0 iff row_buf_ == NULL.
-     */
-
-    n_cols_ = dee_model_get_n_columns(model);
-
-    if (n_cols_ == 0)
-    {
-      LOG_ERROR(logger) << "Source model has not provided a schema for the model merger!";
-      return;
-    }
-
-    /* Lazily adopt schema from source if we don't have one.
-     * If we do have a schema let's validate that they match the source */
-    if (dee_model_get_n_columns(target_) == 0)
-    {
-      dee_model_set_schema_full(target_,
-                                dee_model_get_schema(model, NULL),
-                                n_cols_);
-    }
-    else
-    {
-      unsigned int n_cols1;
-      const gchar* const *schema1 = dee_model_get_schema(target_, &n_cols1);
-      const gchar* const *schema2 = dee_model_get_schema(model, NULL);
-
-      /* At the very least we should have an equal number of rows */
-      if (n_cols_ != n_cols1)
-      {
-        LOG_ERROR(logger) << "Schema mismatch between source and target model. Expected "
-                          << n_cols1 << " columns, but found "
-                          << n_cols_ << ".";
-        n_cols_ = 0;
-        return;
-      }
-
-      /* Compare schemas */
-      for (unsigned int i = 0; i < n_cols_; i++)
-      {
-        if (g_strcmp0(schema1[i], schema2[i]) != 0)
-        {
-          LOG_ERROR(logger) << "Schema mismatch between source and target model. Expected column "
-                            << i << " to be '" << schema1[i] << "', but found '"
-                            << schema2[i] << "'.";
-          n_cols_ = 0;
-          return;
-        }
-      }
-    }
-
-    row_buf_ = g_new0 (GVariant*, n_cols_);
-  }
-}
-
-DeeModelTag* HomeLens::ModelMerger::FindSourceToTargetTag(DeeModel* model)
-{
-  return source_to_target_tags_[model];
-}
-
-void HomeLens::CategoryMerger::RemoveSource(glib::Object<DeeModel> const& source)
-{
-  // call base()
-  HomeLens::ModelMerger::RemoveSource(source);
-
-  cat_registry_->UnregisterAllForModel(source);
-}
-
-std::vector<unsigned> HomeLens::CategoryMerger::GetDefaultOrder()
-{
-  std::vector<unsigned> result;
-  for (auto it = category_ordering_.begin(); it != category_ordering_.end(); ++it)
-  {
-    result.push_back(it->second);
-  }
-
-  return result;
-}
-
-std::string HomeLens::CategoryMerger::GetLensIdForCategory(unsigned cat) const
-{
-  auto lens_it = category_to_owner_.find(cat);
-  if (lens_it != category_to_owner_.end())
-  {
-    if (lens_it->second) return lens_it->second->id();
-  }
-
-  return "";
-}
-
-std::map<unsigned, Lens::Ptr> const&
-HomeLens::CategoryMerger::GetCategoryToLensMap() const
-{
-  return category_to_owner_;
-}
-
-HomeLens::Impl::Impl(HomeLens *owner, MergeMode merge_mode)
-  : owner_(owner)
-  , cat_registry_(owner)
-  , results_merger_(owner->results()->model(), &cat_registry_)
-  , categories_merger_(owner->categories()->model(), &cat_registry_, merge_mode)
-  , filters_merger_(owner->filters()->model())
-  , running_searches_(0)
-  , apps_lens_contains_visible_match(false)
-  , settings_(g_settings_new("com.canonical.Unity.Dash"))
-{
-  DeeModel* results = owner->results()->model();
-  if (dee_model_get_n_columns(results) == 0)
-  {
-    dee_model_set_schema(results, "s", "s", "u", "s", "s", "s", "s", NULL);
-  }
-
-  DeeModel* categories = owner->categories()->model();
-  if (dee_model_get_n_columns(categories) == 0)
-  {
-    dee_model_set_schema(categories, "s", "s", "s", "a{sv}", NULL);
-  }
-
-  DeeModel* filters = owner->filters()->model();
-  if (dee_model_get_n_columns(filters) == 0)
-  {
-    dee_model_set_schema(filters, "s", "s", "s", "s", "a{sv}", "b", "b", "b", NULL);
-  }
-}
-
-HomeLens::Impl::~Impl()
-{
-
-}
-
-/*void HomeLens::Impl::CheckCategories()
-{
-
-}*/
-
-gsize HomeLens::Impl::FindLensPriority (Lens::Ptr& lens)
-{
-  gchar** lenses = g_settings_get_strv(settings_, "home-lens-ordering");
-  gsize pos = 0, len = g_strv_length(lenses);
-
-  for (pos = 0; pos < len; pos++)
-  {
-    if (g_strcmp0(lenses[pos], lens->id().c_str()) == 0)
-      break;
-  }
-
-  g_strfreev(lenses);
-
-  return len - pos;
-}
-
-void HomeLens::Impl::EnsureCategoryAnnotation (Lens::Ptr& lens,
-                                               DeeModel* categories,
-                                               DeeModel* results)
-{
-  if (categories && results)
-  {
-    if (!(DEE_IS_MODEL(results) && DEE_IS_MODEL(categories)))
-    {
-      LOG_ERROR(logger) << "The "
-                        << std::string(DEE_IS_MODEL(results) ? "categories" : "results")
-                        << " model is not a valid DeeModel. ("
-                        << lens->id() << ")";
-      return;
-    }
-
-    g_object_set_data(G_OBJECT(categories),
-                      HOMELENS_RESULTS_MODEL,
-                      results);
-
-    gsize lens_priority = FindLensPriority(lens);
-    g_object_set_data(G_OBJECT(categories),
-                      HOMELENS_PRIORITY,
-                      GSIZE_TO_POINTER(lens_priority));
-
-    LOG_DEBUG(logger) << "Registering results model "  << results
-                      << " and lens priority " << lens_priority
-                      << " on category model " << categories << ". ("
-                      << lens->id() << ")";
-  }
-}
-
-Lens::Ptr HomeLens::Impl::FindLensForUri(std::string const& uri)
-{
-  /* We iterate over all lenses looking for the given uri in their
-   * global results. This might seem like a sucky approach, but it
-   * saves us from a ship load of book keeping */
-
-  for (auto lens : lenses_)
-  {
-    DeeModel* results = lens->global_results()->model();
-    DeeModelIter* iter = dee_model_get_first_iter(results);
-    DeeModelIter* end = dee_model_get_last_iter(results);
-    const int URI_COLUMN = 0;
-
-    while (iter != end)
-      {
-        if (g_strcmp0(uri.c_str(), dee_model_get_string(results, iter, URI_COLUMN)) == 0)
-        {
-          return lens;
-        }
-        iter = dee_model_next(results, iter);
-      }
-  }
-
-  return Lens::Ptr();
-}
-
-// FIXME: Coordinated sorting between the lens bar and home screen categories. Make void FilesystemLenses::Impl::DecrementAndCheckChildrenWaiting() use the gsettings key
-// FIXME: on no results https://bugs.launchpad.net/unity/+bug/711199
-
-void HomeLens::Impl::OnLensAdded (Lens::Ptr& lens)
-{
-  lenses_.push_back (lens);
-  owner_->lens_added.emit(lens);
-
-  nux::ROProperty<glib::Object<DeeModel>>& results_prop = lens->global_results()->model;
-  nux::ROProperty<glib::Object<DeeModel>>& categories_prop = lens->categories()->model;
-  nux::ROProperty<glib::Object<DeeModel>>& filters_prop = lens->filters()->model;
-
-  /*
-   * Important: We must ensure that the categories model is annotated
-   *            with the results model in the "unity-homelens-results-model"
-   *            data slot. We need it later to compute the transfermed offsets
-   *            of the categories in the merged category model.
-   */
-
-  /* Most lenses add models lazily, but we can't know that;
-   * so try to see if we can add them up front */
-  if (lens->connected())
-  {
-    if (results_prop())
-    {
-      EnsureCategoryAnnotation(lens, categories_prop(), results_prop());
-      results_merger_.AddSource(lens, results_prop());
-    }
-
-    if (categories_prop())
-    {
-      EnsureCategoryAnnotation(lens, categories_prop(), results_prop());
-      categories_merger_.AddSource(lens, categories_prop());
-    }
-
-    if (filters_prop())
-      filters_merger_.AddSource(lens, filters_prop());
-  }
-
-  /* Make sure the models are properly annotated when they change */
-  lens->models_changed.connect([&] ()
-  {
-    EnsureCategoryAnnotation(lens, lens->categories()->model(),
-                             lens->global_results()->model());
-    categories_merger_.AddSource(lens, lens->categories()->model());
-    results_merger_.AddSource(lens, lens->global_results()->model());
-    filters_merger_.AddSource(lens, lens->filters()->model());
-  });
-
-  /*
-   * Register pre-existing categories up front
-   * FIXME: Do the same for results?
-   */
-  DeeModel* cats = categories_prop();
-  if (cats)
-  {
-    DeeModelIter* cats_iter;
-    DeeModelIter* cats_end;
-    for (cats_iter = dee_model_get_first_iter(cats), cats_end = dee_model_get_last_iter(cats);
-        cats_iter != cats_end;
-        cats_iter = dee_model_next(cats, cats_iter))
-    {
-      categories_merger_.OnSourceRowAdded(cats, cats_iter);
-    }
-  }
-}
-
-void HomeLens::Impl::LensSearchFinished(Lens::Ptr const& lens)
-{
-  auto order_vector = categories_merger_.GetDefaultOrder();
-
-  // get number of results per category
-  std::map<unsigned, unsigned> results_per_cat;
-  for (unsigned i = 0; i < order_vector.size(); i++)
-  {
-    unsigned category = order_vector.at(i);
-    auto model = owner_->GetFilterModelForCategory(category);
-    results_per_cat[category] = model ? dee_model_get_n_rows(model) : 0;
-  }
-
-  CategorySorter sorter(results_per_cat,
-                        categories_merger_.GetCategoryToLensMap());
-  // stable sort based on number of results in each cat
-  std::stable_sort(order_vector.begin(), order_vector.end(), sorter);
-
-  // ensure shopping is second, need map[cat] = lens
-  int shopping_index = -1;
-  int apps_index = -1;
-  for (unsigned i = 0; i < order_vector.size(); i++)
-  {
-    // get lens that owns this category
-    std::string const& lens_id(categories_merger_.GetLensIdForCategory(order_vector.at(i)));
-    if (lens_id == "shopping.lens")
-      shopping_index = i;
-    else if (lens_id == "applications.lens")
-      apps_index = i;
-  }
-
-  if (lens->id() == "applications.lens")
-  {
-    // checking the results isn't extermely fast, so cache the result
-    apps_lens_contains_visible_match = ResultsContainVisibleMatch(order_vector[apps_index]);
-  }
-
-  // if there are no results in the apps category, we can't reorder,
-  // otherwise shopping won't end up being 2nd
-  if (apps_lens_contains_visible_match && apps_index > 0 && 
-      results_per_cat[order_vector[apps_index]] > 0)
-  {
-    // we want apps first
-    unsigned apps_cat_num = order_vector.at(apps_index);
-    order_vector.erase(order_vector.begin() + apps_index);
-    order_vector.insert(order_vector.begin(), apps_cat_num);
-
-    // we might shift the shopping index
-    if (shopping_index >= 0 && shopping_index < apps_index) shopping_index++;
-  }
-
-  if (shopping_index >= 0 && shopping_index != 2)
-  {
-    unsigned shopping_cat_num = order_vector.at(shopping_index);
-    order_vector.erase(order_vector.begin() + shopping_index);
-    order_vector.insert(order_vector.size() > 2 ? order_vector.begin() + 2 : order_vector.end(), shopping_cat_num);
-  }
-
-  if (cached_categories_order_ != order_vector)
-  {
-    cached_categories_order_ = order_vector;
-    owner_->categories_reordered();
-  }
-
-  owner_->lens_search_finished.emit(lens);
-}
-
-bool HomeLens::Impl::ResultsContainVisibleMatch(unsigned category)
-{
-  // this method searches for match of the search string in the display name
-  // or comment fields
-  auto filter_model = owner_->GetFilterModelForCategory(category);
-  if (!filter_model) return false;
-  if (last_search_string_.empty()) return true;
-
-  int checked_results = 5;
-
-  glib::Object<DeeModel> model(dee_sequence_model_new());
-  dee_model_set_schema(model, "s", "s", NULL);
-
-  DeeModelIter* iter = dee_model_get_first_iter(filter_model);
-  DeeModelIter* end_iter = dee_model_get_last_iter(filter_model);
-
-  // add first few results to the temporary model
-  while (iter != end_iter)
-  {
-    glib::Variant name(dee_model_get_value(filter_model, iter, RESULTS_NAME_COLUMN),
-                       glib::StealRef());
-    glib::Variant comment(dee_model_get_value(filter_model, iter, RESULTS_COMMENT_COLUMN),
-                          glib::StealRef());
-    GVariant* members[2] = { name, comment };
-    dee_model_append_row(model, members);
-
-    iter = dee_model_next(filter_model, iter);
-    if (--checked_results <= 0) break;
-  }
-
-  if (dee_model_get_n_rows(model) == 0) return false;
-
-  // setup model reader, analyzer and instantiate an index
-  DeeModelReader reader;
-  dee_model_reader_new([] (DeeModel* m, DeeModelIter* iter, gpointer data) -> gchar*
-    {
-      return g_strdup_printf("%s\n%s",
-        dee_model_get_string(m, iter, 0),
-        dee_model_get_string(m, iter, 1));
-    }, NULL, NULL, &reader);
-  glib::Object<DeeAnalyzer> analyzer(DEE_ANALYZER(dee_text_analyzer_new()));
-  dee_analyzer_add_term_filter(analyzer,
-                               [] (DeeTermList* terms_in, DeeTermList* terms_out, gpointer data) -> void
-                               {
-                                 auto filter = static_cast<DeeICUTermFilter*>(data);
-                                 for (unsigned i = 0; i < dee_term_list_num_terms(terms_in); i++)
-                                 {
-                                   dee_term_list_add_term(terms_out, dee_icu_term_filter_apply(filter, dee_term_list_get_term(terms_in, i)));
-                                 }
-                               },
-                               dee_icu_term_filter_new_ascii_folder(),
-                               (GDestroyNotify)dee_icu_term_filter_destroy);
-  // ready to instantiate the index
-  glib::Object<DeeIndex> index(DEE_INDEX(dee_tree_index_new(model, analyzer, &reader)));
-
-  // tokenize the search string, so this will work with multiple words
-  glib::Object<DeeTermList> search_terms(DEE_TERM_LIST(g_object_new(DEE_TYPE_TERM_LIST, NULL)));
-  dee_analyzer_tokenize(analyzer, last_search_string_.c_str(), search_terms);
-
-  std::set<DeeModelIter*> iters;
-  for (unsigned i = 0; i < dee_term_list_num_terms(search_terms); i++)
-  {
-    glib::Object<DeeResultSet> results(dee_index_lookup(index, dee_term_list_get_term(search_terms, i), DEE_TERM_MATCH_PREFIX));
-    if (i == 0)
-    {
-      while (dee_result_set_has_next(results))
-      {
-        iters.insert(dee_result_set_next(results));
-      }
-    }
-    else
-    {
-      std::set<DeeModelIter*> iters2;
-      while (dee_result_set_has_next(results))
-      {
-        iters2.insert(dee_result_set_next(results));
-      }
-      // intersect the sets, set iterators are stable, so we can do this
-      auto it = iters.begin();
-      while (it != iters.end())
-      {
-        if (iters2.find(*it) == iters2.end())
-          iters.erase(it++);
-        else
-          ++it;
-      }
-      // no need to check more terms if the base set is already empty
-      if (iters.empty()) break;
-    }
-  }
-
-  // there is a match if the iterator is isn't empty
-  return !iters.empty();
-}
-
-std::vector<unsigned> HomeLens::Impl::GetCategoriesOrder()
-{
-  auto default_order = categories_merger_.GetDefaultOrder();
-  if (!last_search_string_.empty() &&
-      cached_categories_order_.size() == default_order.size())
-  {
-    return cached_categories_order_;
-  }
-  return default_order;
-}
-
-HomeLens::HomeLens(std::string const& name,
-                   std::string const& description,
-                   std::string const& search_hint,
-                   MergeMode merge_mode)
-  : Lens("home.lens", "", "", name, PKGDATADIR"/lens-nav-home.svg",
-         description, search_hint, true, "",
-         ModelType::LOCAL)
-  , pimpl(new Impl(this, merge_mode))
-{
-  count.SetGetterFunction(sigc::mem_fun(&pimpl->lenses_, &Lenses::LensList::size));
-  last_search_string.SetGetterFunction(sigc::mem_fun(pimpl, &HomeLens::Impl::last_search_string));
-  last_global_search_string.SetGetterFunction(sigc::mem_fun(pimpl, &HomeLens::Impl::last_search_string));
-
-  search_in_global = false;
-}
-
-HomeLens::~HomeLens()
-{
-  delete pimpl;
-}
-
-void HomeLens::AddLenses(Lenses::Ptr const& lenses)
-{
-  for (auto lens : lenses->GetLenses())
-  {
-    pimpl->OnLensAdded(lens);
-  }
-
-  lenses->lens_added.connect(sigc::mem_fun(pimpl, &HomeLens::Impl::OnLensAdded));
-}
-
-Lenses::LensList HomeLens::GetLenses() const
-{
-  return pimpl->lenses_;
-}
-
-Lens::Ptr HomeLens::GetLens(std::string const& lens_id) const
-{
-  for (auto lens: pimpl->lenses_)
-  {
-    if (lens->id == lens_id)
-    {
-      return lens;
-    }
-  }
-
-  return Lens::Ptr();
-}
-
-Lens::Ptr HomeLens::GetLensAtIndex(std::size_t index) const
-{
-  try
-  {
-    return pimpl->lenses_.at(index);
-  }
-  catch (std::out_of_range& error)
-  {
-    LOG_WARN(logger) << error.what();
-  }
-
-  return Lens::Ptr();
-}
-
-Lens::Ptr HomeLens::GetLensForShortcut(std::string const& lens_shortcut) const
-{
-  return Lens::Ptr();
-}
-
-void HomeLens::GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb)
-{
-  LOG_WARN(logger) << "Global search not enabled for HomeLens class."
-                   << " Ignoring query '" << search_string << "'";
-}
-
-void HomeLens::Search(std::string const& search_string, SearchFinishedCallback const& cb)
-{
-  LOG_DEBUG(logger) << "Search '" << search_string << "'";
-
-  pimpl->last_search_string_ = search_string;
-  pimpl->apps_lens_contains_visible_match = false;
-  auto running_searches = std::make_shared<int>();
-
-  for (auto lens: pimpl->lenses_)
-  {
-    if (lens->search_in_global())
-    {
-      (*running_searches.get())++;
-      auto closure = [this, lens, running_searches, cb] (Hints const&, glib::Error const&)
-      {
-        int remaining_searches = --(*running_searches.get());
-        pimpl->LensSearchFinished(lens);
-
-        if (remaining_searches <= 0)
-        {
-          cb(Hints(), glib::Error());
-          LOG_INFO(logger) << "Global search finished";
-        }
-      };
-
-      LOG_INFO(logger) << " - Global search on '" << lens->id() << "' for '"
-          << search_string << "'";
-      lens->view_type = ViewType::HOME_VIEW;
-      lens->GlobalSearch(search_string, closure);
-    }
-  }
-}
-
-void HomeLens::Activate(std::string const& uri)
-{
-  LOG_DEBUG(logger) << "Activate '" << uri << "'";
-
-  Lens::Ptr lens = pimpl->FindLensForUri(uri);
-
-  /* Fall back to default handling of URIs if no lens is found.
-   *  - Although, this shouldn't really happen */
-  if (lens)
-  {
-    LOG_DEBUG(logger) << "Activation request passed to '" << lens->id() << "'";
-    lens->Activate(uri);
-  }
-  else
-  {
-    LOG_WARN(logger) << "Unable to find a lens for activating '" << uri
-                     << "'. Using fallback activation.";
-    activated.emit(uri, HandledType::NOT_HANDLED, Hints());
-  }
-}
-
-void HomeLens::Preview(std::string const& uri)
-{
-  LOG_DEBUG(logger) << "Preview '" << uri << "'";
-
-  Lens::Ptr lens = pimpl->FindLensForUri(uri);
-
-  if (lens)
-    lens->Preview(uri);
-  else
-    LOG_WARN(logger) << "Unable to find a lens for previewing '" << uri << "'";
-}
-
-std::vector<unsigned> HomeLens::GetCategoriesOrder()
-{
-  return pimpl->GetCategoriesOrder();
-}
-
-glib::Object<DeeModel> HomeLens::GetFilterModelForCategory(unsigned category)
-{
-  auto it = pimpl->category_filter_models_.find(category);
-  if (it != pimpl->category_filter_models_.end()) return it->second;
-
-  auto model = Lens::GetFilterModelForCategory(category);
-  pimpl->category_filter_models_[category] = model;
-  return model;
-}
-
-}
-}

=== removed file 'UnityCore/HomeLens.h'
--- UnityCore/HomeLens.h	2013-03-12 15:21:19 +0000
+++ UnityCore/HomeLens.h	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-// -*- 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: Mikkel Kamstrup Erlandsen <[e-mail]>
- */
-
-#ifndef UNITY_HOME_LENS_H
-#define UNITY_HOME_LENS_H
-
-#include <vector>
-#include <memory>
-#include <sigc++/signal.h>
-#include <sigc++/trackable.h>
-
-#include "Lenses.h"
-#include "Lens.h"
-
-namespace unity
-{
-namespace dash
-{
-
-/**
- * A special Lens implementation that merges together a set of source Lens
- * instances.
- *
- * NOTE: Changes in the filter models are currently not propagated back to the
- *       the source lenses. If we want to support filters on the dash home
- *       screen this needs to be addressed.
- */
-class HomeLens : public Lens, public Lenses
-{
-public:
-  typedef std::shared_ptr<HomeLens> Ptr;
-
-  /* Specifies mode for category merging */
-  enum MergeMode
-  {
-    DISPLAY_NAME,
-    OWNER_LENS
-  };
-
-  /**
-   * Should be constructed with i18n arguments:
-   *                         _("Home"), _("Home screen"), _("Search")
-   */
-  HomeLens(std::string const& name,
-           std::string const& description,
-           std::string const& search_hint,
-           MergeMode merge_mode = MergeMode::OWNER_LENS);
-  virtual ~HomeLens();
-
-  void AddLenses(Lenses::Ptr const& lenses);
-
-  Lenses::LensList GetLenses() const override;
-  Lens::Ptr GetLens(std::string const& lens_id) const override;
-  Lens::Ptr GetLensAtIndex(std::size_t index) const override;
-  Lens::Ptr GetLensForShortcut(std::string const& lens_shortcut) const override;
-
-  void GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb);
-  void Search(std::string const& search_string, SearchFinishedCallback const& cb);
-  void Activate(std::string const& uri);
-  void Preview(std::string const& uri);
-
-  std::vector<unsigned> GetCategoriesOrder();
-  glib::Object<DeeModel> GetFilterModelForCategory(unsigned category);
-
-  // emitted when global search for one lens finishes
-  sigc::signal<void, Lens::Ptr const&> lens_search_finished;
-
-private:
-  class Impl;
-  class ModelMerger;
-  class ResultsMerger;
-  class CategoryMerger;
-  class FiltersMerger;
-  class CategoryRegistry;
-  Impl* pimpl;
-};
-
-}
-}
-
-#endif

=== removed file 'UnityCore/Lens.cpp'
--- UnityCore/Lens.cpp	2013-03-21 19:11:44 +0000
+++ UnityCore/Lens.cpp	1970-01-01 00:00:00 +0000
@@ -1,885 +0,0 @@
-// -*- 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]>
- */
-
-#include "Lens.h"
-
-#include <gio/gio.h>
-#include <glib.h>
-#include <NuxCore/Logger.h>
-#include <unity-protocol.h>
-
-#include "config.h"
-#include "GLibDBusProxy.h"
-#include "GLibWrapper.h"
-
-namespace unity
-{
-namespace dash
-{
-DECLARE_LOGGER(logger, "unity.dash.lens");
-
-namespace
-{
-const unsigned CATEGORY_COLUMN = 2;
-}
-
-using std::string;
-
-class Lens::Impl
-{
-public:
-  Impl(Lens* owner,
-       string const& id,
-       string const& dbus_name,
-       string const& dbus_path,
-       string const& name,
-       string const& icon_hint,
-       string const& description,
-       string const& search_hint,
-       bool visible,
-       string const& shortcut,
-       ModelType model_type);
-
-  void OnProxyConnectionChanged();
-  void OnProxyDisconnected();
-
-  unsigned long long ExtractModelSeqnum(GVariant *parameters);
-  void WaitForModelUpdate(glib::Variant const& response_variant,
-                          Results::Ptr const& model,
-                          std::function<void(Hints const&)> const& callback);
-  void SearchCallFinished(GVariant* response, glib::Error const& error,
-                          Results::Ptr const& model,
-                          SearchFinishedCallback const& cb);
-
-  void OnChanged(GVariant* parameters);
-  void UpdateProperties(bool search_in_global,
-                        bool visible,
-                        string const& search_hint,
-                        string const& private_connection_name,
-                        string const& results_model_name,
-                        string const& global_results_model_name,
-                        string const& categories_model_name,
-                        string const& filters_model_name,
-                        GVariantIter* hints_iter);
-  void OnViewTypeChanged(ViewType view_type);
-
-  void GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb);
-  void Search(std::string const& search_string, SearchFinishedCallback const& cb);
-  void Activate(std::string const& uri);
-  void ActivationReply(GVariant* parameters);
-  void Preview(std::string const& uri);
-  void ActivatePreviewAction(std::string const& action_id,
-                             std::string const& uri,
-                             Hints const& hints);
-  void SignalPreview(std::string const& preview_uri,
-                     glib::Variant const& preview_update,
-                     glib::DBusProxy::ReplyCallback reply_cb);
-  std::vector<unsigned> GetCategoriesOrder();
-  glib::Object<DeeModel> GetFilterModelForCategory(unsigned category);
-  void GetFilterForCategoryIndex(unsigned category, DeeFilter* filter);
-
-  string const& id() const;
-  string const& dbus_name() const;
-  string const& dbus_path() const;
-  string const& name() const;
-  string const& icon_hint() const;
-  string const& description() const;
-  string const& search_hint() const;
-  bool visible() const;
-  bool search_in_global() const;
-  bool set_search_in_global(bool val);
-  string const& shortcut() const;
-  Results::Ptr const& results() const;
-  Results::Ptr const& global_results() const;
-  Categories::Ptr const& categories() const;
-  Filters::Ptr const& filters() const;
-  bool connected() const;
-  bool provides_personal_content() const;
-
-  string const& last_search_string() const { return last_search_string_; }
-  string const& last_global_search_string() const { return last_global_search_string_; }
-
-  Lens* owner_;
-
-  string id_;
-  string dbus_name_;
-  string dbus_path_;
-  string name_;
-  string icon_hint_;
-  string description_;
-  string search_hint_;
-  bool visible_;
-  bool search_in_global_;
-  string shortcut_;
-  Results::Ptr results_;
-  Results::Ptr global_results_;
-  Categories::Ptr categories_;
-  Filters::Ptr filters_;
-  bool connected_;
-  bool provides_personal_content_;
-
-  string private_connection_name_;
-  string last_search_string_;
-  string last_global_search_string_;
-
-  glib::DBusProxy::Ptr proxy_;
-  glib::Cancellable search_cancellable_;
-  glib::Cancellable global_search_cancellable_;
-  glib::Cancellable preview_cancellable_;
-
-  glib::Variant results_variant_;
-  glib::Variant global_results_variant_;
-};
-
-Lens::Impl::Impl(Lens* owner,
-                 string const& id,
-                 string const& dbus_name,
-                 string const& dbus_path,
-                 string const& name,
-                 string const& icon_hint,
-                 string const& description,
-                 string const& search_hint,
-                 bool visible,
-                 string const& shortcut,
-                 ModelType model_type)
-  : owner_(owner)
-  , id_(id)
-  , dbus_name_(dbus_name)
-  , dbus_path_(dbus_path)
-  , name_(name)
-  , icon_hint_(icon_hint)
-  , description_(description)
-  , search_hint_(search_hint)
-  , visible_(visible)
-  , search_in_global_(false)
-  , shortcut_(shortcut)
-  , results_(new Results(model_type))
-  , global_results_(new Results(model_type))
-  , categories_(new Categories(model_type))
-  , filters_(new Filters(model_type))
-  , connected_(false)
-  , provides_personal_content_(false)
-{
-  if (model_type == ModelType::REMOTE)
-  {
-    proxy_ = std::make_shared<glib::DBusProxy>(dbus_name, dbus_path, "com.canonical.Unity.Lens");
-    proxy_->connected.connect(sigc::mem_fun(this, &Lens::Impl::OnProxyConnectionChanged));
-    proxy_->disconnected.connect(sigc::mem_fun(this, &Lens::Impl::OnProxyDisconnected));
-    proxy_->Connect("Changed", sigc::mem_fun(this, &Lens::Impl::OnChanged));
-  }
-
-  owner_->id.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::id));
-  owner_->dbus_name.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::dbus_name));
-  owner_->dbus_path.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::dbus_path));
-  owner_->name.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::name));
-  owner_->icon_hint.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::icon_hint));
-  owner_->description.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::description));
-  owner_->search_hint.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::search_hint));
-  owner_->visible.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::visible));
-  owner_->search_in_global.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::search_in_global));
-  owner_->search_in_global.SetSetterFunction(sigc::mem_fun(this, &Lens::Impl::set_search_in_global));
-  owner_->shortcut.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::shortcut));
-  owner_->results.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::results));
-  owner_->global_results.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::global_results));
-  owner_->categories.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::categories));
-  owner_->filters.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::filters));
-  owner_->connected.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::connected));
-  owner_->provides_personal_content.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::provides_personal_content));
-  owner_->last_search_string.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::last_search_string));
-  owner_->last_global_search_string.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::last_global_search_string));
-  owner_->view_type.changed.connect(sigc::mem_fun(this, &Lens::Impl::OnViewTypeChanged));
-}
-
-void Lens::Impl::OnProxyConnectionChanged()
-{
-  if (proxy_->IsConnected())
-  {
-    proxy_->Call("InfoRequest");
-    ViewType current_view_type = owner_->view_type;
-    proxy_->Call("SetViewType", g_variant_new("(u)", current_view_type));
-  }
-}
-
-void Lens::Impl::OnProxyDisconnected()
-{
-  connected_ = false;
-  owner_->connected.EmitChanged(connected_);
-}
-
-void Lens::Impl::WaitForModelUpdate(glib::Variant const& response_variant,
-                                    Results::Ptr const& model,
-                                    std::function<void(Hints const&)> const& callback)
-{
-  // a bit of pointer craziness because using copy constructors screws us up
-  auto con = std::make_shared<sigc::connection>();
-  *con = model->end_transaction.connect([this, response_variant, model, callback, con]
-                                       (unsigned long long begin_seqnum,
-                                        unsigned long long end_seqnum)
-  {
-    if (end_seqnum >= ExtractModelSeqnum(response_variant))
-    {
-      Hints hints;
-      response_variant.ASVToHints(hints);
-      callback(hints);
-
-      con->disconnect();
-    }
-  });
-
-  // FIXME: also add a timer and fail the call after ~30 seconds?
-}
-
-unsigned long long Lens::Impl::ExtractModelSeqnum(GVariant *parameters)
-{
-  GVariant *dict;
-  guint64 seqnum64;
-  unsigned long long seqnum = 0;
-
-  dict = g_variant_get_child_value (parameters, 0);
-  if (dict)
-  {
-    if (g_variant_lookup (dict, "model-seqnum", "t", &seqnum64))
-    {
-      seqnum = static_cast<unsigned long long> (seqnum64);
-    }
-
-    g_variant_unref (dict);
-  }
-
-  return seqnum;
-}
-
-void Lens::Impl::OnChanged(GVariant* parameters)
-{
-  glib::String dbus_path;
-  gboolean search_in_global = FALSE;
-  gboolean visible = FALSE;
-  glib::String search_hint;
-  glib::String private_connection_name;
-  glib::String results_model_name;
-  glib::String global_results_model_name;
-  glib::String categories_model_name;
-  glib::String filters_model_name;
-  GVariantIter* hints_iter = NULL;
-
-  g_variant_get(parameters, "((sbbssssssa{sv}))",
-                &dbus_path,
-                &search_in_global,
-                &visible,
-                &search_hint,
-                &private_connection_name,
-                &results_model_name,
-                &global_results_model_name,
-                &categories_model_name,
-                &filters_model_name,
-                &hints_iter);
-
-  LOG_DEBUG(logger) << "Lens info changed for " << name_ << "\n"
-                    << "  Path: " << dbus_path << "\n"
-                    << "  SearchInGlobal: " << search_in_global << "\n"
-                    << "  Visible: " << visible << "\n"
-                    << "  PrivateConnName: " << private_connection_name << "\n"
-                    << "  Results: " << results_model_name << "\n"
-                    << "  GlobalModel: " << global_results_model_name << "\n"
-                    << "  Categories: " << categories_model_name << "\n"
-                    << "  Filters: " << filters_model_name << "\n";
-  if (dbus_path.Str() == dbus_path_)
-  {
-    std::string categories_model_swarm_name(categories_model_name.Str());
-    std::string filters_model_swarm_name(filters_model_name.Str());
-    std::string results_model_swarm_name(results_model_name.Str());
-    std::string global_results_model_swarm_name(global_results_model_name.Str());
-    bool models_changed = 
-      categories_model_swarm_name != categories_->swarm_name ||
-      filters_model_swarm_name != filters_->swarm_name ||
-      results_model_swarm_name != results_->swarm_name ||
-      global_results_model_swarm_name != global_results_->swarm_name;
-
-    /* FIXME: We ignore hints for now */
-    UpdateProperties(search_in_global,
-                     visible,
-                     search_hint.Str(),
-                     private_connection_name.Str(),
-                     results_model_swarm_name,
-                     global_results_model_swarm_name,
-                     categories_model_swarm_name,
-                     filters_model_swarm_name,
-                     hints_iter);
-
-    if (models_changed) owner_->models_changed.emit();
-  }
-  else
-  {
-    LOG_WARNING(logger) << "Paths do not match " << dbus_path_ << " != " << dbus_path;
-  }
-
-  if (!connected_)
-  {
-    connected_ = true;
-    owner_->connected.EmitChanged(connected_);
-  }
-
-  g_variant_iter_free(hints_iter);
-}
-
-void Lens::Impl::UpdateProperties(bool search_in_global,
-                                  bool visible,
-                                  string const& search_hint,
-                                  string const& private_connection_name,
-                                  string const& results_model_name,
-                                  string const& global_results_model_name,
-                                  string const& categories_model_name,
-                                  string const& filters_model_name,
-                                  GVariantIter* hints_iter)
-{
-  // Diff the properties received from those we have
-  if (search_hint_ != search_hint)
-  {
-    search_hint_ = search_hint;
-    owner_->search_hint.EmitChanged(search_hint_);
-  }
-
-  if (search_in_global_ != search_in_global)
-  {
-    search_in_global_ = search_in_global;
-    owner_->search_in_global.EmitChanged(search_in_global_);
-  }
-
-  if (visible_ != visible)
-  {
-    visible_ = visible;
-    owner_->visible.EmitChanged(visible_);
-  }
-
-  bool provides_personal_content = false;
-  gchar* key;
-  GVariant* value;
-
-  // g_variant_iter_loop manages the memory automatically, as long
-  // as the iteration is not stopped in the middle
-  while (g_variant_iter_loop(hints_iter, "{sv}", &key, &value))
-  {
-    if (g_strcmp0(key, "provides-personal-content") == 0)
-    {
-      provides_personal_content = g_variant_get_boolean(value) != FALSE;
-    }
-  }
-
-  if (provides_personal_content_ != provides_personal_content)
-  {
-    provides_personal_content_ = provides_personal_content;
-    owner_->provides_personal_content.EmitChanged(provides_personal_content_);
-  }
-
-  if (private_connection_name_ != private_connection_name)
-  {
-    // FIXME: Update all the models as they are no longer valid when we use this
-    private_connection_name_ = private_connection_name;
-  }
-  categories_->swarm_name = categories_model_name;
-  filters_->swarm_name = filters_model_name;
-  global_results_->swarm_name = global_results_model_name;
-  results_->swarm_name = results_model_name;
-}
-
-void Lens::Impl::OnViewTypeChanged(ViewType view_type)
-{
-  if (proxy_ && proxy_->IsConnected())
-    proxy_->Call("SetViewType", g_variant_new("(u)", view_type));
-}
-
-void Lens::Impl::SearchCallFinished(GVariant* response, glib::Error const& error, Results::Ptr const& model, SearchFinishedCallback const& cb)
-{
-  if (!error)
-  {
-    auto reply_seqnum = ExtractModelSeqnum(response);
-    if (model->seqnum < reply_seqnum)
-    {
-      WaitForModelUpdate(response, model, [this, cb] (Hints const& hints)
-      {
-        if (cb) cb(hints, glib::Error());
-      });
-    }
-    else
-    {
-      Hints hints;
-      glib::Variant dict(response);
-      dict.ASVToHints(hints);
-      if (cb) cb(hints, glib::Error());
-    }
-  }
-  else
-  {
-    // call failed
-    if (cb) cb(Hints(), error);
-  }
-}
-
-void Lens::Impl::GlobalSearch(std::string const& search_string,
-                              SearchFinishedCallback const& cb)
-{
-  LOG_DEBUG(logger) << "Global Searching '" << id_ << "' for '" << search_string << "'";
-
-  GVariantBuilder b;
-  g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
-
-  global_search_cancellable_.Renew();
-
-  last_global_search_string_ = search_string;
-
-  proxy_->CallBegin("GlobalSearch",
-                    g_variant_new("(sa{sv})",
-                                  search_string.c_str(),
-                                  &b),
-                    [this, cb] (GVariant* response, glib::Error const& error)
-                    {
-                      SearchCallFinished(response, error, global_results_, cb);
-                    },
-                    global_search_cancellable_);
-
-  g_variant_builder_clear(&b);
-}
-
-void Lens::Impl::Search(std::string const& search_string,
-                        SearchFinishedCallback const& cb)
-{
-  LOG_DEBUG(logger) << "Searching '" << id_ << "' for '" << search_string << "'";
-
-  if (proxy_ == NULL)
-  {
-    LOG_DEBUG(logger) << "Skipping search. Proxy not initialized. ('" << id_ << "')";
-    return;
-  }
-
-  GVariantBuilder b;
-  g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
-
-  search_cancellable_.Renew();
-
-  last_search_string_ = search_string;
-
-  proxy_->CallBegin("Search",
-                    g_variant_new("(sa{sv})",
-                                  search_string.c_str(),
-                                  &b),
-                    [this, cb] (GVariant* response, glib::Error const& error)
-                    {
-                      SearchCallFinished(response, error, results_, cb);
-                    },
-                    search_cancellable_);
-
-  g_variant_builder_clear(&b);
-}
-
-void Lens::Impl::Activate(std::string const& uri)
-{
-  LOG_DEBUG(logger) << "Activating '" << uri << "' on  '" << id_ << "'";
-
-  if (!proxy_->IsConnected())
-    {
-      LOG_DEBUG(logger) << "Skipping activation. Proxy not connected. ('" << id_ << "')";
-      return;
-    }
-
-  proxy_->Call("Activate",
-               g_variant_new("(su)", uri.c_str(),
-                             UNITY_PROTOCOL_ACTION_TYPE_ACTIVATE_RESULT),
-               sigc::mem_fun(this, &Lens::Impl::ActivationReply));
-}
-
-void Lens::Impl::ActivationReply(GVariant* parameters)
-{
-  glib::String uri;
-  guint32 handled;
-  GVariant* hints_variant;
-  Hints hints;
-  
-  g_variant_get(parameters, "((su@a{sv}))", &uri, &handled, &hints_variant);
-
-  glib::Variant dict (hints_variant, glib::StealRef());
-  dict.ASVToHints(hints);
-
-  if (handled == UNITY_PROTOCOL_HANDLED_TYPE_SHOW_PREVIEW)
-  {
-    auto iter = hints.find("preview");
-    if (iter != hints.end())
-    {
-      Preview::Ptr preview(Preview::PreviewForVariant(iter->second));
-      if (preview)
-      {
-        // would be nice to make parent_lens a shared_ptr,
-        // but that's not really doable from here
-        preview->parent_lens = owner_;
-        preview->preview_uri = uri.Str();
-        owner_->preview_ready.emit(uri.Str(), preview);
-        return;
-      }
-    }
-
-    LOG_WARNING(logger) << "Unable to deserialize Preview";
-  }
-  else
-  {
-    owner_->activated.emit(uri.Str(), static_cast<HandledType>(handled), hints);
-  }
-}
-
-void Lens::Impl::Preview(std::string const& uri)
-{
-  LOG_DEBUG(logger) << "Previewing '" << uri << "' on  '" << id_ << "'";
-
-  if (!proxy_->IsConnected())
-    {
-      LOG_DEBUG(logger) << "Skipping preview. Proxy not connected. ('" << id_ << "')";
-      return;
-    }
-
-  preview_cancellable_.Renew();
-
-  proxy_->Call("Activate",
-               g_variant_new("(su)", uri.c_str(),
-                             UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_RESULT),
-               sigc::mem_fun(this, &Lens::Impl::ActivationReply),
-               preview_cancellable_);
-}
-
-void Lens::Impl::ActivatePreviewAction(std::string const& action_id,
-                                       std::string const& uri,
-                                       Hints const& hints)
-{
-  LOG_DEBUG(logger) << "Activating action '" << action_id << "' on  '" << id_ << "'";
-
-  if (!proxy_->IsConnected())
-    {
-      LOG_DEBUG(logger) << "Skipping activation. Proxy not connected. ('" << id_ << "')";
-      return;
-    }
-
-  std::string activation_uri(action_id);
-  activation_uri += ":";
-  activation_uri += uri;
-
-  if (hints.empty())
-  {
-    // FIXME: we should really be using the (sua{sv}) method all the time,
-    // but we're past freezes and having to logout and back in is
-    // too big of a deal after beta freeze
-    proxy_->Call("Activate",
-                 g_variant_new("(su)", activation_uri.c_str(),
-                               UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION),
-                 sigc::mem_fun(this, &Lens::Impl::ActivationReply));
-  }
-  else
-  {
-    GVariantBuilder b;
-    g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
-
-    for (auto it = hints.begin(); it != hints.end(); ++it)
-    {
-      GVariant* variant = it->second;
-      g_variant_builder_add(&b, "{sv}", it->first.c_str(), variant);
-    }
-
-    proxy_->Call("ActivateWithHints",
-                 g_variant_new("(sua{sv})", activation_uri.c_str(),
-                               UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION,
-                               &b),
-                 sigc::mem_fun(this, &Lens::Impl::ActivationReply));
-
-    g_variant_builder_clear(&b);
-  }
-}
-
-void Lens::Impl::SignalPreview(std::string const& preview_uri,
-                               glib::Variant const& preview_update,
-                               glib::DBusProxy::ReplyCallback reply_cb)
-{
-  LOG_DEBUG(logger) << "Signalling preview '" << preview_uri << "' on  '" << id_ << "'";
-
-  if (!proxy_->IsConnected())
-    {
-      LOG_DEBUG(logger) << "Can't signal preview. Proxy not connected. ('" << id_ << "')";
-      return;
-    }
-
-  GVariant *preview_update_variant = preview_update;
-  proxy_->Call("UpdatePreviewProperty",
-               g_variant_new("(s@a{sv})", preview_uri.c_str(),
-                             preview_update_variant),
-               reply_cb);
-}
-
-std::vector<unsigned> Lens::Impl::GetCategoriesOrder()
-{
-  std::vector<unsigned> result;
-  for (std::size_t i=0; i < categories_->count; i++)
-  {
-    result.push_back(i);
-  }
-
-  return result;
-}
-
-glib::Object<DeeModel> Lens::Impl::GetFilterModelForCategory(unsigned category)
-{
-  DeeFilter filter;
-  GetFilterForCategoryIndex(category, &filter);
-  glib::Object<DeeModel> filter_model(dee_filter_model_new(results_->model(), &filter));
-
-  return filter_model;
-}
-
-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;
-}
-
-void Lens::Impl::GetFilterForCategoryIndex(unsigned category, DeeFilter* filter)
-{
-  filter->map_func = category_filter_map_func;
-  filter->map_notify = category_filter_notify_func;
-  filter->destroy = nullptr;
-  filter->userdata = GUINT_TO_POINTER(category);
-}
-
-string const& Lens::Impl::id() const
-{
-  return id_;
-}
-
-string const& Lens::Impl::dbus_name() const
-{
-  return dbus_name_;
-}
-
-string const& Lens::Impl::dbus_path() const
-{
-  return dbus_path_;
-}
-
-string const& Lens::Impl::name() const
-{
-  return name_;
-}
-
-string const& Lens::Impl::icon_hint() const
-{
-  return icon_hint_;
-}
-
-string const& Lens::Impl::description() const
-{
-  return description_;
-}
-
-string const& Lens::Impl::search_hint() const
-{
-  return search_hint_;
-}
-
-bool Lens::Impl::visible() const
-{
-  return visible_;
-}
-
-bool Lens::Impl::search_in_global() const
-{
-  return search_in_global_;
-}
-
-bool Lens::Impl::set_search_in_global(bool val)
-{
-  if (search_in_global_ != val)
-  {
-    search_in_global_ = val;
-    owner_->search_in_global.EmitChanged(val);
-  }
-
-  return search_in_global_;
-}
-
-string const& Lens::Impl::shortcut() const
-{
-  return shortcut_;
-}
-
-Results::Ptr const& Lens::Impl::results() const
-{
-  return results_;
-}
-
-Results::Ptr const& Lens::Impl::global_results() const
-{
-  return global_results_;
-}
-
-Categories::Ptr const& Lens::Impl::categories() const
-{
-  return categories_;
-}
-
-Filters::Ptr const& Lens::Impl::filters() const
-{
-  return filters_;
-}
-
-bool Lens::Impl::connected() const
-{
-  return connected_;
-}
-
-bool Lens::Impl::provides_personal_content() const
-{
-  return provides_personal_content_;
-}
-
-Lens::Lens(string const& id_,
-           string const& dbus_name_,
-           string const& dbus_path_,
-           string const& name_,
-           string const& icon_hint_,
-           string const& description_,
-           string const& search_hint_,
-           bool visible_,
-           string const& shortcut_)
-
-  : pimpl(new Impl(this,
-                   id_,
-                   dbus_name_,
-                   dbus_path_,
-                   name_,
-                   icon_hint_,
-                   description_,
-                   search_hint_,
-                   visible_,
-                   shortcut_,
-                   ModelType::REMOTE))
-{}
-
-Lens::Lens(string const& id_,
-            string const& dbus_name_,
-            string const& dbus_path_,
-            string const& name_,
-            string const& icon_hint_,
-            string const& description_,
-            string const& search_hint_,
-            bool visible_,
-            string const& shortcut_,
-            ModelType model_type)
-
-  : pimpl(new Impl(this,
-                   id_,
-                   dbus_name_,
-                   dbus_path_,
-                   name_,
-                   icon_hint_,
-                   description_,
-                   search_hint_,
-                   visible_,
-                   shortcut_,
-                   model_type))
-{}
-
-Lens::~Lens()
-{
-  delete pimpl;
-}
-
-void Lens::GlobalSearch(std::string const& search_string,
-                        SearchFinishedCallback const& cb)
-{
-  pimpl->GlobalSearch(search_string, cb);
-}
-
-void Lens::Search(std::string const& search_string,
-                  SearchFinishedCallback const& cb)
-{
-  pimpl->Search(search_string, cb);
-}
-
-void Lens::Activate(std::string const& uri)
-{
-  pimpl->Activate(uri);
-}
-
-void Lens::Preview(std::string const& uri)
-{
-  pimpl->Preview(uri);
-}
-
-void Lens::ActivatePreviewAction(std::string const& action_id,
-                                 std::string const& uri,
-                                 Hints const& hints)
-{
-  pimpl->ActivatePreviewAction(action_id, uri, hints);
-}
-
-void Lens::SignalPreview(std::string const& uri,
-                         glib::Variant const& preview_update,
-                         glib::DBusProxy::ReplyCallback reply_cb)
-{
-  pimpl->SignalPreview(uri, preview_update, reply_cb);
-}
-
-std::vector<unsigned> Lens::GetCategoriesOrder()
-{
-  return pimpl->GetCategoriesOrder();
-}
-
-glib::Object<DeeModel> Lens::GetFilterModelForCategory(unsigned category)
-{
-  return pimpl->GetFilterModelForCategory(category);
-}
-
-
-}
-}

=== removed file 'UnityCore/Lens.h'
--- UnityCore/Lens.h	2012-11-14 08:57:56 +0000
+++ UnityCore/Lens.h	1970-01-01 00:00:00 +0000
@@ -1,140 +0,0 @@
-// -*- 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]>
- */
-
-#ifndef UNITY_LENS_H
-#define UNITY_LENS_H
-
-#include <boost/noncopyable.hpp>
-#include <memory>
-#include <NuxCore/Property.h>
-#include <sigc++/trackable.h>
-
-#include "Variant.h"
-#include "GLibDBusProxy.h"
-#include "Categories.h"
-#include "Filters.h"
-#include "Preview.h"
-#include "Results.h"
-
-namespace unity
-{
-namespace dash
-{
-
-enum HandledType
-{
-  NOT_HANDLED=0,
-  SHOW_DASH,
-  HIDE_DASH,
-  GOTO_DASH_URI
-};
-
-enum ViewType
-{
-  HIDDEN=0,
-  HOME_VIEW,
-  LENS_VIEW
-};
-
-class Lens : public sigc::trackable, boost::noncopyable
-{
-public:
-  typedef std::shared_ptr<Lens> Ptr;
-  typedef std::map<std::string, unity::glib::Variant> Hints;
-  typedef std::function<void(Hints const&, glib::Error const&)> SearchFinishedCallback;
-
-  Lens(std::string const& id,
-       std::string const& dbus_name,
-       std::string const& dbus_path,
-       std::string const& name,
-       std::string const& icon,
-       std::string const& description = "",
-       std::string const& search_hint = "",
-       bool visible = true,
-       std::string const& shortcut = "");
-
-  Lens(std::string const& id,
-         std::string const& dbus_name,
-         std::string const& dbus_path,
-         std::string const& name,
-         std::string const& icon,
-         std::string const& description,
-         std::string const& search_hint,
-         bool visible,
-         std::string const& shortcut,
-         ModelType model_type);
-
-  virtual ~Lens();
-
-  virtual void GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb = nullptr);
-  virtual void Search(std::string const& search_string, SearchFinishedCallback const& cb = nullptr);
-  virtual void Activate(std::string const& uri);
-  virtual void Preview(std::string const& uri);
-  virtual void ActivatePreviewAction(std::string const& action_id,
-                                     std::string const& uri,
-                                     Hints const& hints);
-  virtual void SignalPreview(std::string const& uri,
-      glib::Variant const& preview_update,
-      glib::DBusProxy::ReplyCallback reply_cb = nullptr);
-
-  /**
-   * Note that this model is only valid for as long as the results model
-   * doesn't change.
-   * (you should call this again after models_changed is emitted)
-   */
-  virtual glib::Object<DeeModel> GetFilterModelForCategory(unsigned category);
-  virtual std::vector<unsigned> GetCategoriesOrder();
-
-  nux::RWProperty<std::string> id;
-  nux::RWProperty<std::string> dbus_name;
-  nux::RWProperty<std::string> dbus_path;
-  nux::RWProperty<std::string> name;
-  nux::RWProperty<std::string> icon_hint;
-  nux::RWProperty<std::string> description;
-  nux::RWProperty<std::string> search_hint;
-  nux::RWProperty<bool> visible;
-  nux::RWProperty<bool> search_in_global;
-  nux::RWProperty<std::string> shortcut;
-  nux::RWProperty<Results::Ptr> results;
-  nux::RWProperty<Results::Ptr> global_results;
-  nux::RWProperty<Categories::Ptr> categories;
-  nux::RWProperty<Filters::Ptr> filters;
-  nux::RWProperty<bool> connected;
-  nux::RWProperty<bool> provides_personal_content;
-  nux::ROProperty<std::string> last_search_string;
-  nux::ROProperty<std::string> last_global_search_string;
-
-  nux::Property<ViewType> view_type;
-
-  sigc::signal<void> categories_reordered;
-  /* Emitted when any of the models' swarm name changes, but collates the name
-   * changes into a single signal emission (when all are changed) */
-  sigc::signal<void> models_changed;
-  sigc::signal<void, std::string const&, HandledType, Hints const&> activated;
-  sigc::signal<void, std::string const&, Preview::Ptr const&> preview_ready;
-
-private:
-  class Impl;
-  Impl* pimpl;
-};
-
-}
-}
-
-#endif

=== removed file 'UnityCore/Lenses.h'
--- UnityCore/Lenses.h	2013-03-12 15:21:19 +0000
+++ UnityCore/Lenses.h	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-// -*- 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]>
- */
-
-#ifndef UNITY_LENSES_H
-#define UNITY_LENSES_H
-
-#include <memory>
-#include <sigc++/trackable.h>
-#include <sigc++/signal.h>
-
-#include "Lens.h"
-
-namespace unity
-{
-namespace dash
-{
-
-class Lenses : public sigc::trackable, boost::noncopyable
-{
-public:
-  typedef std::shared_ptr<Lenses> Ptr;
-  typedef std::vector<Lens::Ptr> LensList;
-
-  /**
-   * Get the currently loaded Lenses. 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 Lenses may already have been loaded by the time
-   * the objects have been initiated (and so just connecting to the signals is not
-   * enough)
-   */
-  virtual LensList GetLenses() const = 0;
-  virtual Lens::Ptr GetLens(std::string const& lens_id) const = 0;
-  virtual Lens::Ptr GetLensAtIndex(std::size_t index) const = 0;
-  virtual Lens::Ptr GetLensForShortcut(std::string const& lens_shortcut) const = 0;
-
-  nux::ROProperty<std::size_t> count;
-
-  sigc::signal<void, Lens::Ptr&> lens_added;
-};
-
-}
-}
-
-#endif

=== added file 'UnityCore/MiscUtils.h'
--- UnityCore/MiscUtils.h	1970-01-01 00:00:00 +0000
+++ UnityCore/MiscUtils.h	2013-05-15 21:06: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-05-15 21:06: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>
@@ -169,7 +201,7 @@
 }
 
 template<class RowAdaptor>
-const RowAdaptor Model<RowAdaptor>::RowAtIndex(std::size_t index)
+const RowAdaptor Model<RowAdaptor>::RowAtIndex(std::size_t index) const
 {
   RowAdaptor it(model_,
                 dee_model_get_iter_at_row(model_, index),
@@ -178,13 +210,13 @@
 }
 
 template<class RowAdaptor>
-DeeModelTag* Model<RowAdaptor>::GetTag()
+DeeModelTag* Model<RowAdaptor>::GetTag() const
 {
   return renderer_tag_;
 }
 
 template<class RowAdaptor>
-std::size_t Model<RowAdaptor>::get_count()
+std::size_t Model<RowAdaptor>::get_count() const
 {
   if (model_)
     return dee_model_get_n_rows(model_);
@@ -193,7 +225,7 @@
 }
 
 template<class RowAdaptor>
-unsigned long long Model<RowAdaptor>::get_seqnum()
+unsigned long long Model<RowAdaptor>::get_seqnum() const
 {
   if (model_ && DEE_IS_SERIALIZABLE_MODEL ((DeeModel*) model_))
     return dee_serializable_model_get_seqnum(model_);
@@ -202,7 +234,7 @@
 }
 
 template<class RowAdaptor>
-glib::Object<DeeModel> Model<RowAdaptor>::get_model()
+glib::Object<DeeModel> Model<RowAdaptor>::get_model() const
 {
   return model_;
 }

=== modified file 'UnityCore/Model.h'
--- UnityCore/Model.h	2012-09-02 20:34:37 +0000
+++ UnityCore/Model.h	2013-05-15 21:06: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();
+  const RowAdaptor RowAtIndex(std::size_t index) const;
+  DeeModelTag*     GetTag() const;
 
   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);
@@ -79,9 +86,9 @@
   void OnTransactionBegin(DeeModel* model, guint64 begin_seq, guint64 end_seq);
   void OnTransactionEnd(DeeModel* model, guint64 begin_seq, guint64 end_seq);
   void OnSwarmNameChanged(std::string const& swarm_name);
-  std::size_t get_count();
-  unsigned long long get_seqnum();
-  glib::Object<DeeModel> get_model();
+  std::size_t get_count() const;
+  unsigned long long get_seqnum() const;
+  glib::Object<DeeModel> get_model() const;
 
 private:
   glib::Object<DeeModel> model_;
@@ -94,8 +101,8 @@
   RowAdaptor cached_adaptor3_;
 };
 
-}
-}
+} // namespace dash
+} // namespace unity
 
 #include "Model-inl.h"
 

=== renamed file 'UnityCore/ResultIterator.cpp' => 'UnityCore/ModelIterator-inl.h'
--- UnityCore/ResultIterator.cpp	2013-04-04 22:45:50 +0000
+++ UnityCore/ModelIterator-inl.h	2013-05-15 21:06:29 +0000
@@ -17,15 +17,14 @@
  * Authored by: Gordon Allott <[e-mail]>
  */
 
-#include "ResultIterator.h"
-#include <NuxCore/Logger.h>
+ 
 namespace unity
 {
 namespace dash
 {
-DECLARE_LOGGER(logger, "unity.dash.resultiterator");
 
-ResultIterator::ResultIterator(glib::Object<DeeModel> model)
+template<class Adaptor>
+ModelIterator<Adaptor>::ModelIterator(glib::Object<DeeModel> model)
   : model_(model)
   , iter_(model ? dee_model_get_first_iter(model) : NULL)
   , tag_(NULL)
@@ -33,7 +32,8 @@
 {
 }
 
-ResultIterator::ResultIterator(glib::Object<DeeModel> model, DeeModelIter* iter, DeeModelTag* tag)
+template<class Adaptor>
+ModelIterator<Adaptor>::ModelIterator(glib::Object<DeeModel> model, DeeModelIter* iter, DeeModelTag* tag)
   : model_(model)
   , iter_(iter)
   , tag_(tag)
@@ -41,12 +41,14 @@
 {
 }
 
-ResultIterator ResultIterator::operator[](int value)
+template<class Adaptor>
+ModelIterator<Adaptor> ModelIterator<Adaptor>::operator[](int value)
 {
-  return ResultIterator(model_, dee_model_get_iter_at_row(model_, value), tag_);
+  return ModelIterator<Adaptor>(model_, dee_model_get_iter_at_row(model_, value), tag_);
 }
 
-ResultIterator& ResultIterator::operator=(ResultIterator const& rhs)
+template<class Adaptor>
+ModelIterator<Adaptor>& ModelIterator<Adaptor>::operator=(ModelIterator const& rhs)
 {
   model_ = rhs.model_;
   iter_ = rhs.iter_;
@@ -56,13 +58,15 @@
   return *this;
 }
 
-ResultIterator& ResultIterator::operator++()
+template<class Adaptor>
+ModelIterator<Adaptor>& ModelIterator<Adaptor>::operator++()
 {
   iter_ = dee_model_next(model_, iter_);
   return *this;
 }
 
-ResultIterator& ResultIterator::operator+=(int count)
+template<class Adaptor>
+ModelIterator<Adaptor>& ModelIterator<Adaptor>::operator+=(int count)
 {
   if (dee_model_is_last(model_, iter_))
     return *this;
@@ -73,27 +77,31 @@
   return *this;
 }
 
-ResultIterator ResultIterator::operator++(int)
+template<class Adaptor>
+ModelIterator<Adaptor> ModelIterator<Adaptor>::operator++(int)
 {
-  ResultIterator tmp(*this);
+  ModelIterator tmp(*this);
   operator++();
   return tmp;
 }
 
-ResultIterator ResultIterator::operator+(int count) const
+template<class Adaptor>
+ModelIterator<Adaptor> ModelIterator<Adaptor>::operator+(int count) const
 {
-  ResultIterator tmp(*this);
+  ModelIterator tmp(*this);
   tmp += count;
   return tmp;
 }
 
-ResultIterator& ResultIterator::operator--()
+template<class Adaptor>
+ModelIterator<Adaptor>& ModelIterator<Adaptor>::operator--()
 {
   iter_ = dee_model_prev(model_, iter_);
   return *this;
 }
 
-ResultIterator& ResultIterator::operator-=(int count)
+template<class Adaptor>
+ModelIterator<Adaptor>& ModelIterator<Adaptor>::operator-=(int count)
 {
   if (dee_model_is_first(model_, iter_))
     return *this;
@@ -104,33 +112,38 @@
   return *this;
 }
 
-ResultIterator ResultIterator::operator--(int)
+template<class Adaptor>
+ModelIterator<Adaptor> ModelIterator<Adaptor>::operator--(int)
 {
-  ResultIterator tmp(*this);
+  ModelIterator<Adaptor> tmp(*this);
   operator--();
   return tmp;
 }
 
-ResultIterator ResultIterator::operator-(int count) const
+template<class Adaptor>
+ModelIterator<Adaptor> ModelIterator<Adaptor>::operator-(int count) const
 {
-  ResultIterator tmp(*this);
+  ModelIterator<Adaptor> tmp(*this);
   tmp -= count;
   return tmp;
 }
 
-Result& ResultIterator::operator*()
+template<class Adaptor>
+Adaptor& ModelIterator<Adaptor>::operator*()
 {
   iter_result_.SetTarget(model_, iter_, tag_);
   return iter_result_;
 }
 
-bool ResultIterator::IsLast()
+template<class Adaptor>
+bool ModelIterator<Adaptor>::IsLast()
 {
   if (!model_) return true;
   return (dee_model_is_last(model_, iter_));
 }
 
-bool ResultIterator::IsFirst()
+template<class Adaptor>
+bool ModelIterator<Adaptor>::IsFirst()
 {
   if (!model_) return true;
   return (dee_model_is_first(model_, iter_));

=== renamed file 'UnityCore/ResultIterator.h' => 'UnityCore/ModelIterator.h'
--- UnityCore/ResultIterator.h	2013-04-03 05:48:20 +0000
+++ UnityCore/ModelIterator.h	2013-05-15 21:06:29 +0000
@@ -16,12 +16,11 @@
  *
  * Authored by: Gordon Allott <[e-mail]>
  */
-#ifndef UNITY_RESULT_ITERATOR_H
-#define UNITY_RESULT_ITERATOR_H
+#ifndef UNITY_MODEL_ITERATOR_H
+#define UNITY_MODEL_ITERATOR_H
 
 #include <dee.h>
 #include <iterator>
-#include "Result.h"
 #include "GLibWrapper.h"
 
 namespace unity
@@ -32,57 +31,58 @@
 // Provides an iterator that will iterate a DeeModel from a Results object
 // based on the category you give it
 
-class ResultIterator : public std::iterator<std::random_access_iterator_tag, Result>
+template<class Adaptor>
+class ModelIterator : public std::iterator<std::random_access_iterator_tag, Adaptor>
 {
 public:
-  ResultIterator(glib::Object<DeeModel> model);
-  ResultIterator(glib::Object<DeeModel> model, DeeModelIter* iter_, DeeModelTag* tag);
-  ResultIterator(ResultIterator const& copy) : model_(copy.model_), iter_(copy.iter_), tag_(copy.tag_), iter_result_(copy.iter_result_){};
+  ModelIterator(glib::Object<DeeModel> model);
+  ModelIterator(glib::Object<DeeModel> model, DeeModelIter* iter_, DeeModelTag* tag);
+  ModelIterator(ModelIterator const& copy) : model_(copy.model_), iter_(copy.iter_), tag_(copy.tag_), iter_result_(copy.iter_result_){};
 
-  ResultIterator& operator=(ResultIterator const& rhs);
+  ModelIterator& operator=(ModelIterator const& rhs);
 
   //Iterator methods
-  ResultIterator& operator++();
-  ResultIterator  operator++(int);
-  ResultIterator& operator+=(int value);
-  ResultIterator  operator+(int value) const;
-
-  ResultIterator& operator--();
-  ResultIterator  operator--(int);
-  ResultIterator& operator-=(int value);
-  ResultIterator  operator-(int value) const;
-
-  ResultIterator operator[](int value);
-  friend inline bool operator<(const ResultIterator& lhs, const ResultIterator& rhs)
+  ModelIterator& operator++();
+  ModelIterator  operator++(int);
+  ModelIterator& operator+=(int value);
+  ModelIterator  operator+(int value) const;
+
+  ModelIterator& operator--();
+  ModelIterator  operator--(int);
+  ModelIterator& operator-=(int value);
+  ModelIterator  operator-(int value) const;
+
+  ModelIterator operator[](int value);
+  friend inline bool operator<(const ModelIterator& lhs, const ModelIterator& rhs)
   {
     return (dee_model_get_position(lhs.model_, lhs.iter_) < dee_model_get_position(rhs.model_, rhs.iter_));
   }
 
-  friend inline bool operator>(const ResultIterator& lhs, const ResultIterator& rhs)
+  friend inline bool operator>(const ModelIterator& lhs, const ModelIterator& rhs)
   {
     return (dee_model_get_position(lhs.model_, lhs.iter_) > dee_model_get_position(rhs.model_, rhs.iter_));
   }
 
-  friend inline bool operator<=(const ResultIterator& lhs, const ResultIterator& rhs)
+  friend inline bool operator<=(const ModelIterator& lhs, const ModelIterator& rhs)
   {
     return (dee_model_get_position(lhs.model_, lhs.iter_) <= dee_model_get_position(rhs.model_, rhs.iter_));
   }
 
-  friend inline bool operator>=(const ResultIterator& lhs, const ResultIterator& rhs)
+  friend inline bool operator>=(const ModelIterator& lhs, const ModelIterator& rhs)
   {
     return (dee_model_get_position(lhs.model_, lhs.iter_) >= dee_model_get_position(rhs.model_, rhs.iter_));
   }
   
-  friend inline bool operator==(const ResultIterator& lhs, const ResultIterator& rhs)
+  friend inline bool operator==(const ModelIterator& lhs, const ModelIterator& rhs)
   {
     return (lhs.iter_ == rhs.iter_);
   }
 
-  friend inline bool operator!=(const ResultIterator& lhs, const ResultIterator& rhs)
+  friend inline bool operator!=(const ModelIterator& lhs, const ModelIterator& rhs)
   {
     return !(lhs == rhs);
   }
-  Result& operator*();
+  Adaptor& operator*();
 
   /* convenience methods */
   bool IsLast();
@@ -92,11 +92,12 @@
   glib::Object<DeeModel> model_;
   DeeModelIter* iter_;
   DeeModelTag* tag_;
-  Result iter_result_;  
+  Adaptor iter_result_;  
 };
 
 }
-
 }
 
+#include "ModelIterator-inl.h"
+
 #endif 

=== modified file 'UnityCore/ModelRowAdaptor.cpp'
--- UnityCore/ModelRowAdaptor.cpp	2012-12-06 17:41:07 +0000
+++ UnityCore/ModelRowAdaptor.cpp	2013-05-15 21:06:29 +0000
@@ -95,6 +95,13 @@
   return static_cast<float>(dee_model_get_double(model_, iter_, position));
 }
 
+glib::Variant RowAdaptorBase::GetVariantAt(int position) const
+{
+  if (!model_ || !iter_)
+    return nullptr;
+  return dee_model_get_value(model_, iter_, position);
+}
+
 void RowAdaptorBase::set_model_tag(gpointer value)
 {
   dee_model_set_tag(model_, iter_, tag_, value);

=== modified file 'UnityCore/ModelRowAdaptor.h'
--- UnityCore/ModelRowAdaptor.h	2012-12-06 17:41:07 +0000
+++ UnityCore/ModelRowAdaptor.h	2013-05-15 21:06:29 +0000
@@ -23,6 +23,7 @@
 #include <string>
 
 #include <dee.h>
+#include "Variant.h"
 
 namespace unity
 {
@@ -59,6 +60,7 @@
   virtual int GetIntAt(int position) const;
   virtual unsigned int GetUIntAt(int position) const;
   virtual float GetFloatAt(int position) const;
+  virtual glib::Variant GetVariantAt(int position) const;
 
   void SetTarget(DeeModel* model, DeeModelIter* iter, DeeModelTag* tag);
 
@@ -68,6 +70,8 @@
   template<typename T>
   T renderer() const;
 
+  DeeModel* model() { return model_; }
+
 protected:
   virtual void set_model_tag(gpointer value);
   virtual gpointer get_model_tag() const;

=== modified file 'UnityCore/MultiRangeFilter.cpp'
--- UnityCore/MultiRangeFilter.cpp	2013-01-30 10:34:09 +0000
+++ UnityCore/MultiRangeFilter.cpp	2013-05-15 21:06:29 +0000
@@ -28,12 +28,14 @@
 DECLARE_LOGGER(logger, "unity.dash.filter.multirange");
 
 MultiRangeFilter::MultiRangeFilter(DeeModel* model, DeeModelIter* iter)
-  : Filter(model, iter)
-  , left_pos_(-1)
-  , right_pos_(-1)
-  , ignore_changes_(false)
+: Filter(model, iter)
+, show_all_button_(true)
+, left_pos_(-1)
+, right_pos_(-1)
+, ignore_changes_(false)
 {
   options.SetGetterFunction(sigc::mem_fun(this, &MultiRangeFilter::get_options));
+  show_all_button.SetGetterFunction(sigc::mem_fun(this, &MultiRangeFilter::get_show_all_button));
   Refresh();
 }
 
@@ -54,6 +56,15 @@
 
 void MultiRangeFilter::Update(Filter::Hints& hints)
 {
+  GVariant* show_all_button_variant = hints["show-all-button"];
+  if (show_all_button_variant)
+  {
+    bool tmp_show = show_all_button_;
+    g_variant_get(show_all_button_variant, "b", &show_all_button_);
+    if (tmp_show != show_all_button_)
+      show_all_button.EmitChanged(show_all_button_);
+  }
+
   GVariant* options_variant = hints["options"];
   GVariantIter* options_iter;
 
@@ -146,6 +157,11 @@
   return options_;
 }
 
+bool MultiRangeFilter::get_show_all_button() const
+{
+  return show_all_button_;
+}
+
 void MultiRangeFilter::UpdateState()
 {
   if (!IsValid())

=== modified file 'UnityCore/MultiRangeFilter.h'
--- UnityCore/MultiRangeFilter.h	2011-08-05 15:54:58 +0000
+++ UnityCore/MultiRangeFilter.h	2013-05-15 21:06:29 +0000
@@ -38,6 +38,7 @@
   void Clear();
 
   nux::ROProperty<Options> options;
+  nux::ROProperty<bool> show_all_button;
 
   sigc::signal<void, FilterOption::Ptr> option_added;
   sigc::signal<void, FilterOption::Ptr> option_removed;
@@ -48,11 +49,13 @@
 private:
   void UpdateState();
   Options const& get_options() const;
+  bool get_show_all_button() const;
   int PositionOfId(std::string const& id);
   void OptionChanged(bool is_active, std::string const& id);
 
 private:
   Options options_;
+  bool show_all_button_;
   int left_pos_;
   int right_pos_;
   bool ignore_changes_;

=== modified file 'UnityCore/MusicPreview.cpp'
--- UnityCore/MusicPreview.cpp	2012-07-12 16:36:54 +0000
+++ UnityCore/MusicPreview.cpp	2013-05-15 21:06:29 +0000
@@ -22,20 +22,20 @@
 
 #include "MusicPreview.h"
 #include "Tracks.h"
+#include "Scope.h"
+#include "PreviewPlayer.h"
 
 namespace unity
 {
 namespace dash
 {
+DECLARE_LOGGER(logger, "unity.dash.musicpreview");
 
 class MusicPreview::Impl
 {
 public:
   Impl(MusicPreview* owner, glib::Object<GObject> const& proto_obj);
 
-  void PlayUri(std::string const& uri) const;
-  void PauseUri(std::string const& uri) const;
-
   MusicPreview* owner_;
 
   glib::Object<UnityProtocolMusicPreview> raw_preview_;
@@ -47,43 +47,15 @@
   : owner_(owner)
   , tracks_model(new Tracks())
 {
-  const gchar* s;
   raw_preview_ = glib::object_cast<UnityProtocolMusicPreview>(proto_obj);
 
-  s = unity_protocol_music_preview_get_track_data_swarm_name(raw_preview_);
-  std::string swarm_name(s != NULL ? s : "");
-  s = unity_protocol_music_preview_get_track_data_address(raw_preview_);
-  std::string peer_address(s != NULL ? s : "");
-
-  // TODO: we're not using private connection yet
-  if (!swarm_name.empty())
+  if (raw_preview_)
   {
-    tracks_model->swarm_name = swarm_name;
+    glib::Object<DeeModel> track_dee_model(DEE_MODEL(unity_protocol_music_preview_get_track_model(raw_preview_)), glib::AddRef());
+    tracks_model->SetModel(track_dee_model);
   }
 }
 
-void MusicPreview::Impl::PlayUri(std::string const& uri) const
-{
-  UnityProtocolPreview *preview = UNITY_PROTOCOL_PREVIEW(raw_preview_.RawPtr());
-
-  unity_protocol_preview_begin_updates(preview);
-  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);
-}
-
-void MusicPreview::Impl::PauseUri(std::string const& uri) const
-{
-  UnityProtocolPreview *preview = UNITY_PROTOCOL_PREVIEW(raw_preview_.RawPtr());
-
-  unity_protocol_preview_begin_updates(preview);
-  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);
-}
-
 MusicPreview::MusicPreview(unity::glib::Object<GObject> const& proto_obj)
   : Preview(proto_obj)
   , pimpl(new Impl(this, proto_obj))
@@ -99,15 +71,5 @@
   return pimpl->tracks_model;
 }
 
-void MusicPreview::PlayUri(std::string const& uri) const
-{
-  pimpl->PlayUri(uri);
-}
-
-void MusicPreview::PauseUri(std::string const& uri) const
-{
-  pimpl->PauseUri(uri);
-}
-
 }
 }

=== modified file 'UnityCore/MusicPreview.h'
--- UnityCore/MusicPreview.h	2012-07-12 16:36:54 +0000
+++ UnityCore/MusicPreview.h	2013-05-15 21:06:29 +0000
@@ -43,9 +43,6 @@
 
   Tracks::Ptr GetTracksModel() const;
 
-  void PlayUri(std::string const& uri) const;
-  void PauseUri(std::string const& uri) const;
-
 private:
   class Impl;
   std::unique_ptr<Impl> pimpl;

=== added file 'UnityCore/PaymentPreview.cpp'
--- UnityCore/PaymentPreview.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/PaymentPreview.cpp	2013-05-15 21:06:29 +0000
@@ -0,0 +1,120 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011-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: Manuel de la Pena <[e-mail]>
+ */
+
+#include <unity-protocol.h>
+
+#include "PaymentPreview.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class PaymentPreview::Impl
+{
+
+public:
+  Impl(PaymentPreview* owner, glib::Object<GObject> const& proto_obj);
+
+  void SetupGetters();
+
+  // getters for the data properties
+
+  std::string get_header() const { return header_; };
+  std::string get_email() const { return email_; };
+  std::string get_payment_method() const { return payment_method_; };
+  std::string get_purchase_prize() const { return purchase_prize_; };
+  std::string get_purchase_type() const { return purchase_type_; };
+  PreviewType get_preview_type() const { return preview_type_; };
+
+  // getters for the lables
+
+  // instance vars
+  PaymentPreview* owner_;
+
+  std::string header_;
+  std::string email_;
+  std::string payment_method_;
+  std::string purchase_prize_;
+  std::string purchase_type_;
+  PaymentPreview::PreviewType preview_type_;
+
+};
+
+PaymentPreview::Impl::Impl(PaymentPreview* owner, glib::Object<GObject> const& proto_obj)
+  : owner_(owner)
+{
+  const gchar* s;
+  auto preview = glib::object_cast<UnityProtocolPaymentPreview>(proto_obj);
+
+  s = unity_protocol_payment_preview_get_header(preview);
+  if (s) header_ = s;
+  s = unity_protocol_payment_preview_get_email(preview);
+  if (s) email_ = s;
+  s = unity_protocol_payment_preview_get_email(preview);
+  if (s) email_ = s;
+  s = unity_protocol_payment_preview_get_payment_method(preview);
+  if (s) payment_method_ = s;
+  s = unity_protocol_payment_preview_get_purchase_prize(preview);
+  if (s) purchase_prize_ = s;
+  s = unity_protocol_payment_preview_get_purchase_type(preview);
+  if (s) purchase_type_ = s;
+  UnityProtocolPreviewPaymentType t = unity_protocol_payment_preview_get_preview_type(preview);
+  switch(t)
+  {
+    case UNITY_PROTOCOL_PREVIEW_PAYMENT_TYPE_APPLICATION:
+      preview_type_ = PaymentPreview::APPLICATION;
+      break;
+    case UNITY_PROTOCOL_PREVIEW_PAYMENT_TYPE_MUSIC:
+      preview_type_ = PaymentPreview::MUSIC;
+      break;
+    case UNITY_PROTOCOL_PREVIEW_PAYMENT_TYPE_ERROR:
+      preview_type_ = PaymentPreview::ERROR;
+      break;
+  }
+  SetupGetters();
+}
+
+void PaymentPreview::Impl::SetupGetters()
+{
+  owner_->header.SetGetterFunction(
+            sigc::mem_fun(this, &PaymentPreview::Impl::get_header));
+  owner_->email.SetGetterFunction(
+            sigc::mem_fun(this, &PaymentPreview::Impl::get_email));
+  owner_->payment_method.SetGetterFunction(
+            sigc::mem_fun(this, &PaymentPreview::Impl::get_payment_method));
+  owner_->purchase_prize.SetGetterFunction(
+            sigc::mem_fun(this, &PaymentPreview::Impl::get_purchase_prize));
+  owner_->preview_type.SetGetterFunction(