Merge lp:~kamstrup/unity/home-lenses into lp:unity

[Mikkel Kamstrup Erlandsen]

Replace the Unity home screen tiles with a "merged lens view" where lenses can contribute any categories they see fit.

settings: introduced a new gsettings key in the com.canonical.Unity.Dash namespace that controls the order of the results on the home screen. We should consider in a later branch having the sorting logic in FilesystemLenses also use this key (still falling back to alphabetical sorting when nothing is set). It empowers users and OEMs to override the default view on the homescreen by putting custom stuff first.

libunity-core: Added a HomeLens class that implements Lens and Lenses interfaces. The typical use case is to add a FilesystemLenses to the HomeLens which will make it automatically merge all lenses found on the fs. In testing we implement custom Lenses instances and add those to the HomeLens in stead.

unityshell: Removed the tiled homescreen and use a bog standard LensView to render the HomeLens in stead. Fixed a bunch of places where we assumed that Lenses' categories were always only appended to. This is no longer true with the HomeLens. Also important: Fix the SetViewType() calling semantics to the lenses when showing/hiding the dash and when switching between the lenses.

Testing it out:
For this branch to work you need also: lp:~kamstrup/unity-lens-applications/home-lenses, lp:~kamstrup/unity-lens-files/home-lenses, and lp:~mhr3/unity-lens-music/home-lenses. Add to that latest bamf. Without these you will not see the correct results.

To validate the results: Make sure that bringing up the dash resets the search and shows you a default view with exactly 3 categories in this order: Recent Apps, Recent Files, and Downloads. Then do a search and validate that you have exactly 3 categories in this order Applications, Files & Folders, and Music.

Finally; launch an app that is not a favorite, then bring up the bring up the dash home screen and assert that the running app is *not* in the recent apps category (but showing in the launcher). Then close the app and bring up the dash again. The app should now show under Recent Apps.

Design review:
Home screen without search: https://bugs.launchpad.net/unity/+bug/885738/+attachment/2690636/+files/unity-home-lens-design-review-1.png
Home screen with search: https://bugs.launchpad.net/unity/+bug/885738/+attachment/2690639/+files/unity-home-lens-design-review-2.png

[Mikkel Kamstrup Erlandsen (kamstrup)]

Meh. Sorry for the i18n noise. No idea how that got here. Will try to remove.

[Mikkel Kamstrup Erlandsen (kamstrup)]

Sigh. bzr insists that I don't have any diff with trunk wrt the translations. Fun and games.

[Mikkel Kamstrup Erlandsen (kamstrup)]

Found it. Amended in r1875.

[Michal Hruby (mhr3)]

Just a note: all the lens branches are now merged in respective trunks.

[Andrea Azzarone (azzar1)]

Is PlacesHomeView.cpp/h still needed?

[Andrea Azzarone (azzar1)]

review: Needs Information

[Michal Hruby (mhr3)]

1519 ~Lens();

I believe this should be virtual now.

1538 template<class RowAdaptor>
1539 Model<RowAdaptor>::Model()

The missing model.SetGetterFunction(...) could be a very nasty surprise in the future.

One of weird things I noticed is that when using keynav in the home view (specifically the down array) sometimes the "See xx more results" doesn't get highlighted and can't be expanded by pressing enter.

review: Needs Fixing

[Andrea Azzarone (azzar1)]

> One of weird things I noticed is that when using keynav in the home view
> (specifically the down array) sometimes the "See xx more results" doesn't get
> highlighted and can't be expanded by pressing enter.

Fixed here https://code.launchpad.net/~andyrock/unity/key-nav

[Mikkel Kamstrup Erlandsen (kamstrup)]

> Is PlacesHomeView.cpp/h still needed

Strictly, no. I didn't delete it because technically the home-lens concept is on a trial run. If design ditches it we'll have to revert to the old view and I didn't want to dig it out of the rev history. Although, I probably should delete it, to have a better looking diffstat :-)

[Mikkel Kamstrup Erlandsen (kamstrup)]

> 1519 ~Lens();
>
> I believe this should be virtual now.

Right. I wonder why the compiler didn't complain. It usually does in these cases. Fixed.

> 1538 template<class RowAdaptor>
> 1539 Model<RowAdaptor>::Model()
>
> The missing model.SetGetterFunction(...) could be a very nasty surprise in the
> future.

Ah, good catch. I created a new Init() method that gets called from the constructors so they can share the setup code. (my favorite hate-pattern. why oh why can't we chain constructors in C++?!?!?!11). Anyway; fixed.

[Mikkel Kamstrup Erlandsen (kamstrup)]

WTF. The diffs seems to be showing that I removed po/unity.pot which I swear I didn't! Let me look into it.

[Mikkel Kamstrup Erlandsen (kamstrup)]

Ok, the diff should be clean in r1881. Please re-review

[Michal Hruby (mhr3)]

One thing that's still missing is resetting the search entry when dash is hidden (or not-resetting the search sent to lenses as https://bugs.launchpad.net/ayatana-design/+bug/914759 requires).

Either would be fine, but right now the search entry isn't reset, while the search is...

review: Needs Fixing

[Mikkel Kamstrup Erlandsen (kamstrup)]

Implemented search state retention as requested by design. Please re-review.

[Mikkel Kamstrup Erlandsen (kamstrup)]

John acked the design review on IRC

[Michal Hruby (mhr3)]

Sorry, but Esc now no longer clears the search entry... I don't think that's desired.

review: Needs Fixing

[Andrea Azzarone (azzar1)]

> Sorry, but Esc now no longer clears the search entry... I don't think that's
> desired.

1866 - else
1867 - search_bar_->search_string = "";

[Mikkel Kamstrup Erlandsen (kamstrup)]

> > Sorry, but Esc now no longer clears the search entry... I don't think that's
> > desired.
>
> 1866 - else
> 1867 - search_bar_->search_string = "";

I am not sure if you mean to back Michal up, or refute his claim Andrea? :-)

In any case, I think I have the right behavior here... When clicking Esc I see:

a) if there is text in the entry the text is cleared, and the dash shows results for the empty search
b) if there is no search, the dash is hidden

As a Corollary, c) hitting Esc twice clears and hides the dash.

[Michal Hruby (mhr3)]

Unfortunately, that's not the behaviour I see (particularly a) doesn't work). Afaict the code Andrea pasted is what handled the "esc and search entry not empty" case, and you removed it...

[Mikkel Kamstrup Erlandsen (kamstrup)]

Hmmm, I can see you are correct looking at the code... I wonder how it could work on my box. I must have been running some almost, but not entirely, identical to what I pushed. Nonetheless; pushed a fix.

[Michal Hruby (mhr3)]

Yep, it's fine now. Approved from me, but I suppose more people want to go through this...

review: Approve

[Neil J. Patel (njpatel)]

237 (and other places): Instead of handling the gchar* yourself, use glib::String from UnityCore/GLibWrapper.h, it autofree's it when it's popped from the stack, so you don't need to worry about g_free in multiple places.

330: Evil, evil kamstrup.

Apart from that, excellent work :)

[Mikkel Kamstrup Erlandsen (kamstrup)]

> 237 (and other places): Instead of handling the gchar* yourself, use
> glib::String from UnityCore/GLibWrapper.h, it autofree's it when it's popped
> from the stack, so you don't need to worry about g_free in multiple places.

Ok, now using glib::String. It required that I add automatic std::string conversion to glib::String in order not to complicate the code - I was wondering if there was a specific reason it wasn't in glib::String already. Seems like a strange omission?

[Michal Hruby (mhr3)]

Neil ACKed this as well, so approving...

=== modified file 'HACKING'
--- HACKING	2012-01-10 16:35:26 +0000
+++ HACKING	2012-01-26 08:37:26 +0000
@@ -39,5 +39,12 @@
 
 Testing is handled through GTest, googles test system, we currently have three test targets; test-gtest, test-gtest-xless, test-gtest-dbus. tests that require Nux should be in test-gtest as they require X, tests that can run headless should be in test-gtest-xless and tests that require dbus should be run with test-gtest-dbus, which tests run with our test service.
 
+To enable debug logging you must set the environment variable UNITY_LOG_SEVERITY to the log domain you
+want to watch and the log level for that domain. For example:
+
+  UNITY_LOG_SEVERITY="unity.dash.lens=DEBUG" standalone-clients/dash
+
+
+
 for more information see the README file
 
 
=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2012-01-17 16:02:39 +0000
+++ UnityCore/CMakeLists.txt	2012-01-26 08:37:26 +0000
@@ -21,6 +21,7 @@
      GLibSignal-inl.h
      GLibWrapper.h
      GLibWrapper-inl.h
+     HomeLens.h
      IndicatorEntry.h
      Indicator.h
      Indicators.h
@@ -53,6 +54,7 @@
      GLibDBusProxy.cpp
      GLibSignal.cpp
      GLibWrapper.cpp
+     HomeLens.cpp
      Indicator.cpp
      IndicatorEntry.cpp
      Indicators.cpp
 
=== modified file 'UnityCore/Categories.cpp'
--- UnityCore/Categories.cpp	2011-07-25 10:54:25 +0000
+++ UnityCore/Categories.cpp	2012-01-26 08:37:26 +0000
@@ -31,6 +31,14 @@
   row_removed.connect(sigc::mem_fun(this, &Categories::OnRowRemoved));
 }
 
+Categories::Categories(ModelType model_type)
+ : Model<Category>::Model(model_type)
+{
+  row_added.connect(sigc::mem_fun(this, &Categories::OnRowAdded));
+  row_changed.connect(sigc::mem_fun(this, &Categories::OnRowChanged));
+  row_removed.connect(sigc::mem_fun(this, &Categories::OnRowRemoved));
+}
+
 void Categories::OnRowAdded(Category& category)
 {
   category_added.emit(category);
 
=== modified file 'UnityCore/Categories.h'
--- UnityCore/Categories.h	2011-07-28 13:34:38 +0000
+++ UnityCore/Categories.h	2012-01-26 08:37:26 +0000
@@ -36,6 +36,7 @@
   typedef std::shared_ptr<Categories> Ptr;
 
   Categories();
+  Categories(ModelType model_type);
 
   sigc::signal<void, Category const&> category_added;
   sigc::signal<void, Category const&> category_changed;
 
=== modified file 'UnityCore/Filters.cpp'
--- UnityCore/Filters.cpp	2011-08-05 09:55:33 +0000
+++ UnityCore/Filters.cpp	2012-01-26 08:37:26 +0000
@@ -56,6 +56,14 @@
   row_removed.connect(sigc::mem_fun(this, &Filters::OnRowRemoved));
 }
 
+Filters::Filters(ModelType 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));
+  row_removed.connect(sigc::mem_fun(this, &Filters::OnRowRemoved));
+}
+
 Filters::~Filters()
 {}
 
 
=== modified file 'UnityCore/Filters.h'
--- UnityCore/Filters.h	2011-08-05 09:55:33 +0000
+++ UnityCore/Filters.h	2012-01-26 08:37:26 +0000
@@ -51,6 +51,7 @@
   typedef std::map<DeeModelIter*, Filter::Ptr> FilterMap;
 
   Filters();
+  Filters(ModelType model_type);
   ~Filters();
 
   Filter::Ptr FilterAtIndex(std::size_t index);
 
=== modified file 'UnityCore/GLibDBusProxy.cpp'
--- UnityCore/GLibDBusProxy.cpp	2012-01-16 15:19:47 +0000
+++ UnityCore/GLibDBusProxy.cpp	2012-01-26 08:37:26 +0000
@@ -72,6 +72,7 @@
             int timeout_msec);
 
   void Connect(string const& signal_name, ReplyCallback callback);
+  bool IsConnected();
 
   static void OnNameAppeared(GDBusConnection* connection, const char* name,
                              const char* name_owner, gpointer impl);
@@ -192,6 +193,11 @@
                            this);
 }
 
+bool DBusProxy::Impl::IsConnected()
+{
+  return connected_;
+}
+
 void DBusProxy::Impl::OnProxyConnectCallback(GObject* source,
                                              GAsyncResult* res,
                                              gpointer impl)
@@ -320,5 +326,10 @@
   pimpl->Connect(signal_name, callback);
 }
 
+bool DBusProxy::IsConnected()
+{
+  return pimpl->IsConnected();
+}
+
 }
 }
 
=== modified file 'UnityCore/GLibDBusProxy.h'
--- UnityCore/GLibDBusProxy.h	2011-12-06 10:39:36 +0000
+++ UnityCore/GLibDBusProxy.h	2012-01-26 08:37:26 +0000
@@ -54,6 +54,7 @@
             int timeout_msec = -1);
 
   void Connect(std::string const& signal_name, ReplyCallback callback);
+  bool IsConnected();
 
   sigc::signal<void> connected;
   sigc::signal<void> disconnected;
 
=== modified file 'UnityCore/GLibWrapper.cpp'
--- UnityCore/GLibWrapper.cpp	2011-12-06 10:39:36 +0000
+++ UnityCore/GLibWrapper.cpp	2012-01-26 08:37:26 +0000
@@ -104,6 +104,11 @@
   return string_;
 }
 
+String::operator std::string()
+{
+  return Str();
+}
+
 String::operator bool() const
 {
   return bool(string_);
 
=== modified file 'UnityCore/GLibWrapper.h'
--- UnityCore/GLibWrapper.h	2011-12-14 18:22:23 +0000
+++ UnityCore/GLibWrapper.h	2012-01-26 08:37:26 +0000
@@ -115,6 +115,7 @@
 
   operator bool() const;
   operator char*();
+  operator std::string();
   gchar* Value();
   std::string Str() const;
 
 
=== added file 'UnityCore/HomeLens.cpp'
--- UnityCore/HomeLens.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/HomeLens.cpp	2012-01-26 08:37:26 +0000
@@ -0,0 +1,957 @@
+// -*- 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]>
+ */
+
+#include <glib.h>
+#include <string>
+#include <stdexcept>
+#include <map>
+
+#include "GLibSignal.h"
+#include "HomeLens.h"
+#include "Lens.h"
+#include "Model.h"
+
+#include "config.h"
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+
+nux::logging::Logger logger("unity.dash.homelens");
+
+}
+
+/*
+ * 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)
+    : is_dirty_(false)
+    , owner_(owner) {}
+
+  int FindCategoryOffset(DeeModel* model, unsigned int source_cat_offset)
+  {
+    glib::String c_id(g_strdup_printf("%u+%p", source_cat_offset, model));
+    std::map<std::string,unsigned int>::iterator i = reg_by_id_.find(c_id);
+
+    if (i != reg_by_id_.end())
+      return i->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 */
+  void RegisterCategoryOffset(DeeModel*     model,
+                                 unsigned int source_cat_offset,
+                                 const gchar*  display_name,
+                                 unsigned int target_cat_offset)
+  {
+    glib::String c_id(g_strdup_printf("%u+%p", source_cat_offset, model));
+
+    std::map<std::string,unsigned int>::iterator i = reg_by_id_.find(c_id);
+    if (i != reg_by_id_.end())
+    {
+      LOG_ERROR(logger) << "Category '" << c_id << "' already registered!";
+      return;
+    }
+
+    if (display_name != NULL)
+    {
+      i = reg_by_display_name_.find(display_name);
+      if (i != reg_by_display_name_.end())
+      {
+        LOG_ERROR(logger) << "Category '" << display_name << "' already registered!";
+        return;
+      }
+    }
+
+    /* Any existing categories with offsets >= target_cat_offset must be
+     * pushed up. Update both maps by id and display name */
+    std::map<std::string,unsigned int>::iterator end = reg_by_id_.end();
+    for (i = reg_by_id_.begin(); i != end; i++)
+    {
+      if (i->second >= target_cat_offset)
+      {
+        i->second = i->second + 1;
+        is_dirty_ = true;
+      }
+    }
+
+    for (i = reg_by_display_name_.begin(), end = reg_by_display_name_.end(); i != end; i++)
+    {
+      if (i->second >= target_cat_offset)
+      {
+        i->second = i->second + 1;
+        is_dirty_ = true;
+      }
+    }
+
+    reg_by_id_[c_id] = target_cat_offset;
+
+    /* 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_offset;
+      LOG_DEBUG(logger) << "Registered category '" << display_name
+                        << "' with source offset " << source_cat_offset
+                        << " and target offset " << target_cat_offset
+                        << ". Id " << c_id;
+    }
+    else
+    {
+      LOG_DEBUG(logger) << "Registered category with source offset "
+                        << source_cat_offset << " and target offset "
+                        << target_cat_offset << ". Id " << c_id;
+    }
+  }
+
+  /* Associate a source results model and category offset with an existing
+   * target category offset */
+  void AssociateCategoryOffset(DeeModel*     model,
+                               unsigned int source_cat_offset,
+                               unsigned int target_cat_offset)
+  {
+    glib::String c_id(g_strdup_printf("%u+%p", source_cat_offset, model));
+
+    std::map<std::string,unsigned int>::iterator i = reg_by_id_.find(c_id);
+    if (i != reg_by_id_.end())
+    {
+      LOG_ERROR(logger) << "Category '" << c_id << "' already registered!";
+      return;
+    }
+
+    reg_by_id_[c_id] = target_cat_offset;
+  }
+
+  /**
+   * Returns true and resets the dirty state if the registry was dirty.
+   * When you've checked a dirty registry you must either clear the
+   * merged results model or recalibrate all category offset in it
+   * (and Unity probably wont support the latter?).
+   */
+  bool CheckDirty()
+  {
+    return is_dirty_ ? (is_dirty_ = false, true) : false;
+  }
+
+private:
+  std::map<std::string,unsigned int> reg_by_id_;
+  std::map<std::string,unsigned int> reg_by_display_name_;
+  bool is_dirty_;
+  HomeLens* owner_;
+};
+
+/*
+ * 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();
+
+  void AddSource(glib::Object<DeeModel> 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:
+  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);
+  void CheckCategoryRegistryDirty();
+
+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);
+
+  void OnSourceRowAdded(DeeModel *model, DeeModelIter *iter);
+  void OnSourceRowRemoved(DeeModel *model, DeeModelIter *iter);
+
+private:
+  HomeLens::CategoryRegistry* cat_registry_;
+  DeeModelTag* priority_tag_;
+};
+
+/*
+ * Pimpl for HomeLens
+ */
+class HomeLens::Impl : public sigc::trackable
+{
+public:
+  Impl(HomeLens* owner);
+  ~Impl();
+
+  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);
+
+  HomeLens* owner_;
+  Lenses::LensList lenses_;
+  HomeLens::CategoryRegistry cat_registry_;
+  HomeLens::ResultsMerger results_merger_;
+  HomeLens::CategoryMerger categories_merger_;
+  HomeLens::ModelMerger filters_merger_;
+  int running_searches_;
+  glib::Object<GSettings> settings_;
+};
+
+/*
+ * 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)
+  : HomeLens::ModelMerger::ModelMerger(target)
+  , cat_registry_(cat_registry)
+  , priority_tag_(dee_model_register_tag(target, NULL))
+{}
+
+HomeLens::ModelMerger::~ModelMerger()
+{
+  if (row_buf_)
+    delete row_buf_;
+}
+
+void HomeLens::ModelMerger::AddSource(glib::Object<DeeModel> source)
+{
+  typedef glib::Signal<void, DeeModel*, DeeModelIter*> RowSignalType;
+
+  if (!source)
+  {
+    LOG_ERROR(logger) << "Trying to add NULL source to ModelMerger";
+    return;
+  }
+
+  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::OnSourceRowAdded(DeeModel *model, DeeModelIter *iter)
+{
+  // Default impl. does nothing.
+  // Note that the filters_merger_ relies on this behavior. Supporting
+  // filters on the home screen is possible, but *quite* tricky.
+  // So...
+  //       Discard ALL the rows!
+}
+
+void HomeLens::ResultsMerger::OnSourceRowAdded(DeeModel *model, DeeModelIter *iter)
+{
+  DeeModelIter* target_iter;
+  DeeModelTag*  target_tag;
+  int target_cat_offset, source_cat_offset;
+  const unsigned int CATEGORY_COLUMN = 2;
+
+  EnsureRowBuf(model);
+  CheckCategoryRegistryDirty();
+
+  dee_model_get_row (model, iter, row_buf_);
+  target_tag = FindSourceToTargetTag(model);
+
+  /* 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_);
+    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;
+  DeeModelIter* target_end;
+  DeeModelTag*  target_tag;
+  int target_cat_offset, source_cat_offset;
+  const gchar* display_name;
+  const unsigned int DISPLAY_NAME_COLUMN = 0;
+  gsize lens_priority, prio;
+
+  EnsureRowBuf(model);
+
+  results_model = static_cast<DeeModel*>(g_object_get_data(
+                              G_OBJECT(model), "unity-homelens-results-model"));
+  if (results_model == NULL)
+  {
+    LOG_DEBUG(logger) << "Category model " << model
+                      << " does not have a results model yet";
+    return;
+  }
+
+  dee_model_get_row (model, iter, row_buf_);
+  target_tag = FindSourceToTargetTag(model);
+  source_cat_offset = dee_model_get_position(model, iter);
+
+  /* If we already have a category registered with the same display name
+   * then we just use that. Otherwise register a new category for it */
+  display_name = dee_model_get_string(model, iter, DISPLAY_NAME_COLUMN);
+  target_cat_offset = cat_registry_->FindCategoryOffset(display_name);
+  if (target_cat_offset >= 0)
+  {
+    cat_registry_->AssociateCategoryOffset(results_model, source_cat_offset,
+                                           target_cat_offset);
+    goto cleanup;
+  }
+
+  /*
+   * Below we can assume that we have a genuinely new category.
+   *
+   * Our goal is to insert the category at a position suitable for its
+   * priority. We insert it as the last item in the set of items which
+   * have equal priority.
+   *
+   * We allow our selves to do linear inserts as we wont expect a lot
+   * of categories.
+   */
+
+  lens_priority = GPOINTER_TO_SIZE(g_object_get_data(
+                              G_OBJECT(model), "unity-homelens-priority"));
+
+  /* Seek correct position in the merged category model */
+  target_iter = dee_model_get_first_iter(target_);
+  target_end = dee_model_get_last_iter(target_);
+  while (target_iter != target_end)
+  {
+    prio = GPOINTER_TO_SIZE(dee_model_get_tag(target_, target_iter, priority_tag_));
+    if (lens_priority > prio)
+      break;
+    target_iter = dee_model_next(target_, target_iter);
+  }
+
+  /* Add the row to the merged categories model and store required metadata */
+  target_iter = dee_model_insert_row_before(target_, target_iter, row_buf_);
+  dee_model_set_tag(model, iter, target_tag, target_iter);
+  dee_model_set_tag(target_, target_iter, priority_tag_, GSIZE_TO_POINTER(lens_priority));
+  target_cat_offset = dee_model_get_position(target_, target_iter);
+  cat_registry_->RegisterCategoryOffset(results_model, source_cat_offset,
+                                        display_name, target_cat_offset);
+
+  cleanup:
+    for (unsigned int i = 0; i < n_cols_; i++) g_variant_unref(row_buf_[i]);
+}
+
+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)
+{
+  CheckCategoryRegistryDirty();
+  ModelMerger::OnSourceRowRemoved(model, iter);
+}
+
+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::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::ResultsMerger::CheckCategoryRegistryDirty()
+{
+  DeeModel* source;
+  DeeModelTag* target_tag;
+  const unsigned int CATEGORY_COLUMN = 2;
+  std::map<DeeModel*,DeeModelTag*>::iterator i, end;
+
+  if (G_LIKELY(!cat_registry_->CheckDirty()))
+    return;
+
+  LOG_DEBUG(logger) << "Category registry marked dirty. Fixing category offsets.";
+
+  /*
+   * Iterate over all results in each source model and re-calculate the
+   * the category offset in the corresponding rows in the target model
+   */
+  for (i = source_to_target_tags_.begin(), end = source_to_target_tags_.end();
+       i != end; i++)
+  {
+    source = i->first;
+    target_tag = i->second;
+
+    DeeModelIter* source_iter = dee_model_get_first_iter(source);
+    DeeModelIter* source_end = dee_model_get_last_iter(source);
+
+    for (source_iter = dee_model_get_first_iter(source), source_end = dee_model_get_last_iter(source);
+         source_iter != source_end;
+         source_iter = dee_model_next(source, source_iter))
+    {
+      DeeModelIter* target_iter = static_cast<DeeModelIter*>(dee_model_get_tag(source, source_iter, target_tag));
+
+      /* No guarantee that rows in the source are mapped to the target */
+      if (target_iter == NULL)
+        continue;
+
+      unsigned int source_cat_offset = dee_model_get_uint32(source, source_iter, CATEGORY_COLUMN);
+      int cat_offset = cat_registry_->FindCategoryOffset(source, source_cat_offset);
+
+      if (G_LIKELY(cat_offset >= 0))
+      {
+        dee_model_set_value(target_, target_iter, CATEGORY_COLUMN,
+                            g_variant_new_uint32(cat_offset));
+      }
+      else
+      {
+        LOG_ERROR(logger) << "No registered category id for category "
+            << source_cat_offset << " on result source model "
+            << source << ".";
+        /* We can't really recover from this :-( */
+      }
+    }
+  }
+}
+
+HomeLens::Impl::Impl(HomeLens *owner)
+  : owner_(owner)
+  , cat_registry_(owner)
+  , results_merger_(owner->results()->model(), &cat_registry_)
+  , categories_merger_(owner->categories()->model(), &cat_registry_)
+  , filters_merger_(owner->filters()->model())
+  , running_searches_(0)
+  , 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),
+                      "unity-homelens-results-model",
+                      results);
+
+    gsize lens_priority = FindLensPriority(lens);
+    g_object_set_data(G_OBJECT(categories),
+                      "unity-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);
+
+  /* When we dispatch a search we inc the search count and when we finish
+   * one we decrease it. When we reach 0 we'll emit search_finished. */
+  lens->global_search_finished.connect([&] (Hints const& hints) {
+      running_searches_--;
+
+      if (running_searches_ <= 0)
+      {
+        owner_->search_finished.emit(Hints());
+        LOG_DEBUG(logger) << "Search finished";
+      }
+  });
+
+  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 (results_prop().RawPtr())
+  {
+    EnsureCategoryAnnotation(lens, categories_prop(), results_prop());
+    results_merger_.AddSource(results_prop());
+  }
+
+  if (categories_prop().RawPtr())
+  {
+    EnsureCategoryAnnotation(lens, categories_prop(), results_prop());
+    categories_merger_.AddSource(categories_prop());
+  }
+
+  if (filters_prop().RawPtr())
+    filters_merger_.AddSource(filters_prop());
+
+  /*
+   * Pick it up when the lens set models lazily.
+   */
+  results_prop.changed.connect([&] (glib::Object<DeeModel> model)
+  {
+    EnsureCategoryAnnotation(lens, lens->categories()->model(), model);
+    results_merger_.AddSource(model);
+  });
+
+  categories_prop.changed.connect([&] (glib::Object<DeeModel> model)
+  {
+    EnsureCategoryAnnotation(lens, model, lens->global_results()->model());
+    categories_merger_.AddSource(model);
+  });
+
+  filters_prop.changed.connect([&] (glib::Object<DeeModel> model)
+  {
+    filters_merger_.AddSource(model);
+  });
+
+  /*
+   * Register pre-existing categories up front
+   * FIXME: Do the same for results?
+   */
+  DeeModel* cats = categories_prop();
+  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);
+  }
+}
+
+HomeLens::HomeLens(std::string const& name, std::string const& description, std::string const& search_hint)
+  : Lens("home.lens", "", "", name, PKGDATADIR"/lens-nav-home.svg",
+         description, search_hint, true, "",
+         ModelType::LOCAL)
+  , pimpl(new Impl(this))
+{
+  count.SetGetterFunction(sigc::mem_fun(&pimpl->lenses_, &Lenses::LensList::size));
+  search_in_global = false;
+}
+
+HomeLens::~HomeLens()
+{
+  delete pimpl;
+}
+
+void HomeLens::AddLenses(Lenses& 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();
+}
+
+void HomeLens::GlobalSearch(std::string const& search_string)
+{
+  LOG_WARN(logger) << "Global search not enabled for HomeLens class."
+                   << " Ignoring query '" << search_string << "'";
+}
+
+void HomeLens::Search(std::string const& search_string)
+{
+  LOG_DEBUG(logger) << "Search '" << search_string << "'";
+
+  /* Reset running search counter */
+  pimpl->running_searches_ = 0;
+
+  for (auto lens: pimpl->lenses_)
+  {
+    if (lens->search_in_global())
+    {
+      LOG_DEBUG(logger) << " - Global search on '" << lens->id() << "' for '"
+          << search_string << "'";
+      lens->view_type = ViewType::HOME_VIEW;
+      lens->GlobalSearch(search_string);
+      pimpl->running_searches_++;
+    }
+  }
+}
+
+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 << "'";
+}
+
+}
+}
 
=== added file 'UnityCore/HomeLens.h'
--- UnityCore/HomeLens.h	1970-01-01 00:00:00 +0000
+++ UnityCore/HomeLens.h	2012-01-26 08:37:26 +0000
@@ -0,0 +1,79 @@
+// -*- 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;
+
+  /**
+   * Should be constructed with i18n arguments:
+   *                         _("Home"), _("Home screen"), _("Search")
+   */
+  HomeLens(std::string const& name, std::string const& description, std::string const& search_hint);
+  virtual ~HomeLens();
+
+  void AddLenses(Lenses& lenses);
+
+  Lenses::LensList GetLenses() const;
+  Lens::Ptr GetLens(std::string const& lens_id) const;
+  Lens::Ptr GetLensAtIndex(std::size_t index) const;
+
+  void GlobalSearch(std::string const& search_string);
+  void Search(std::string const& search_string);
+  void Activate(std::string const& uri);
+  void Preview(std::string const& uri);
+
+private:
+  class Impl;
+  class ModelMerger;
+  class ResultsMerger;
+  class CategoryMerger;
+  class CategoryRegistry;
+  Impl* pimpl;
+};
+
+}
+}
+
+#endif
 
=== modified file 'UnityCore/Lens.cpp'
--- UnityCore/Lens.cpp	2012-01-17 16:02:39 +0000
+++ UnityCore/Lens.cpp	2012-01-26 08:37:26 +0000
@@ -51,11 +51,12 @@
        string const& description,
        string const& search_hint,
        bool visible,
-       string const& shortcut);
+       string const& shortcut,
+       ModelType model_type);
 
   ~Impl();
 
-  void OnProxyConnected();
+  void OnProxyConnectionChanged();
   void OnProxyDisconnected();
 
   void ResultsModelUpdated(unsigned long long begin_seqnum, 
@@ -94,6 +95,7 @@
   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;
@@ -121,7 +123,7 @@
 
   string private_connection_name_;
 
-  glib::DBusProxy proxy_;
+  glib::DBusProxy* proxy_;
   glib::Object<GCancellable> search_cancellable_;
   glib::Object<GCancellable> global_search_cancellable_;
 
@@ -138,7 +140,8 @@
                  string const& description,
                  string const& search_hint,
                  bool visible,
-                 string const& shortcut)
+                 string const& shortcut,
+                 ModelType model_type)
   : owner_(owner)
   , id_(id)
   , dbus_name_(dbus_name)
@@ -150,20 +153,46 @@
   , visible_(visible)
   , search_in_global_(false)
   , shortcut_(shortcut)
-  , results_(new Results())
-  , global_results_(new Results())
-  , categories_(new Categories())
-  , filters_(new Filters())
+  , results_(new Results(model_type))
+  , global_results_(new Results(model_type))
+  , categories_(new Categories(model_type))
+  , filters_(new Filters(model_type))
   , connected_(false)
-  , proxy_(dbus_name, dbus_path, "com.canonical.Unity.Lens")
+  , proxy_(NULL)
   , results_variant_(NULL)
   , global_results_variant_(NULL)
 {
-  proxy_.connected.connect(sigc::mem_fun(this, &Lens::Impl::OnProxyConnected));
-  proxy_.disconnected.connect(sigc::mem_fun(this, &Lens::Impl::OnProxyDisconnected));
-  proxy_.Connect("Changed", sigc::mem_fun(this, &Lens::Impl::OnChanged));
+  if (model_type == ModelType::REMOTE)
+  {
+    proxy_ = new 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));
+  }
+
+  /* Technically these signals will only be fired by remote models, but we
+   * connect them no matter the ModelType. Dee may grow support in the future.
+   */
   results_->end_transaction.connect(sigc::mem_fun(this, &Lens::Impl::ResultsModelUpdated));
   global_results_->end_transaction.connect(sigc::mem_fun(this, &Lens::Impl::GlobalResultsModelUpdated));
+
+  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_->view_type.changed.connect(sigc::mem_fun(this, &Lens::Impl::OnViewTypeChanged));
 }
 
 Lens::Impl::~Impl()
@@ -176,13 +205,19 @@
   {
     g_cancellable_cancel (global_search_cancellable_);
   }
+
+  if (proxy_)
+    delete proxy_;
 }
 
-void Lens::Impl::OnProxyConnected()
+void Lens::Impl::OnProxyConnectionChanged()
 {
-  proxy_.Call("InfoRequest");
-  ViewType current_view_type = owner_->view_type;
-  proxy_.Call("SetViewType", g_variant_new("(u)", current_view_type));
+  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()
@@ -387,12 +422,13 @@
 
 void Lens::Impl::OnViewTypeChanged(ViewType view_type)
 {
-  proxy_.Call("SetViewType", g_variant_new("(u)", view_type));
+  if (proxy_ && proxy_->IsConnected())
+    proxy_->Call("SetViewType", g_variant_new("(u)", view_type));
 }
 
 void Lens::Impl::GlobalSearch(std::string const& search_string)
 {
-  LOG_DEBUG(logger) << "Global Searching " << id_ << " for " << search_string;
+  LOG_DEBUG(logger) << "Global Searching '" << id_ << "' for '" << search_string << "'";
 
   GVariantBuilder b;
   g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
@@ -407,7 +443,7 @@
     global_results_variant_ = NULL;
   }
 
-  proxy_.Call("GlobalSearch",
+  proxy_->Call("GlobalSearch",
               g_variant_new("(sa{sv})",
                             search_string.c_str(),
                             &b),
@@ -418,7 +454,13 @@
 
 void Lens::Impl::Search(std::string const& search_string)
 {
-  LOG_DEBUG(logger) << "Searching " << id_ << " for " << search_string;
+  LOG_DEBUG(logger) << "Searching '" << id_ << "' for '" << search_string << "'";
+
+  if (!proxy_->IsConnected())
+  {
+    LOG_DEBUG(logger) << "Skipping search. Proxy not connected. ('" << id_ << "')";
+    return;
+  }
 
   GVariantBuilder b;
   g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
@@ -432,23 +474,29 @@
     results_variant_ = NULL;
   }
 
-  proxy_.Call("Search",
-              g_variant_new("(sa{sv})",
-                            search_string.c_str(),
-                            &b),
-              sigc::mem_fun(this, &Lens::Impl::OnSearchFinished),
-              search_cancellable_);
+  proxy_->Call("Search",
+               g_variant_new("(sa{sv})",
+                             search_string.c_str(),
+                             &b),
+               sigc::mem_fun(this, &Lens::Impl::OnSearchFinished),
+               search_cancellable_);
 
   g_variant_builder_clear(&b);
 }
 
 void Lens::Impl::Activate(std::string const& uri)
 {
-  LOG_DEBUG(logger) << "Activating " << uri << " on  " << id_;
-
-  proxy_.Call("Activate",
-              g_variant_new("(su)", uri.c_str(), 0),
-              sigc::mem_fun(this, &Lens::Impl::ActivationReply));
+  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(), 0),
+               sigc::mem_fun(this, &Lens::Impl::ActivationReply));
 }
 
 void Lens::Impl::ActivationReply(GVariant* parameters)
@@ -468,11 +516,17 @@
 
 void Lens::Impl::Preview(std::string const& uri)
 {
-  LOG_DEBUG(logger) << "Previewing " << uri << " on  " << id_;
-
-  proxy_.Call("Preview",
-              g_variant_new("(s)", uri.c_str()),
-              sigc::mem_fun(this, &Lens::Impl::PreviewReply));
+  LOG_DEBUG(logger) << "Previewing '" << uri << "' on  '" << id_ << "'";
+
+  if (!proxy_->IsConnected())
+    {
+      LOG_DEBUG(logger) << "Skipping preview. Proxy not connected. ('" << id_ << "')";
+      return;
+    }
+
+  proxy_->Call("Preview",
+               g_variant_new("(s)", uri.c_str()),
+               sigc::mem_fun(this, &Lens::Impl::PreviewReply));
 }
 
 void Lens::Impl::PreviewReply(GVariant* parameters)
@@ -535,6 +589,17 @@
   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_;
@@ -584,25 +649,33 @@
                    description_,
                    search_hint_,
                    visible_,
-                   shortcut_))
-{
-  id.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::id));
-  dbus_name.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::dbus_name));
-  dbus_path.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::dbus_path));
-  name.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::name));
-  icon_hint.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::icon_hint));
-  description.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::description));
-  search_hint.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::search_hint));
-  visible.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::visible));
-  search_in_global.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::search_in_global));
-  shortcut.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::shortcut));
-  results.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::results));
-  global_results.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::global_results));
-  categories.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::categories));
-  filters.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::filters));
-  connected.SetGetterFunction(sigc::mem_fun(pimpl, &Lens::Impl::connected));
-  view_type.changed.connect(sigc::mem_fun(pimpl, &Lens::Impl::OnViewTypeChanged));
-}
+                   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()
 {
 
=== modified file 'UnityCore/Lens.h'
--- UnityCore/Lens.h	2012-01-17 13:31:52 +0000
+++ UnityCore/Lens.h	2012-01-26 08:37:26 +0000
@@ -67,12 +67,23 @@
        bool visible = true,
        std::string const& shortcut = "");
 
-  ~Lens();
-
-  void GlobalSearch(std::string const& search_string);
-  void Search(std::string const& search_string);
-  void Activate(std::string const& uri);
-  void Preview(std::string const& uri);
+  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);
+  virtual void Search(std::string const& search_string);
+  virtual void Activate(std::string const& uri);
+  virtual void Preview(std::string const& uri);
 
   nux::RWProperty<std::string> id;
   nux::RWProperty<std::string> dbus_name;
 
=== modified file 'UnityCore/Model-inl.h'
--- UnityCore/Model-inl.h	2012-01-10 14:14:17 +0000
+++ UnityCore/Model-inl.h	2012-01-26 08:37:26 +0000
@@ -34,10 +34,28 @@
 
 template<class RowAdaptor>
 Model<RowAdaptor>::Model()
+  : model_type_(ModelType::REMOTE)
+{
+  Init();
+}
+
+template<class RowAdaptor>
+Model<RowAdaptor>::Model (ModelType model_type)
+  : model_type_(model_type)
+{
+  Init();
+
+  if (model_type == ModelType::LOCAL)
+    swarm_name = ":local";
+}
+
+template<class RowAdaptor>
+void Model<RowAdaptor>::Init ()
 {
   swarm_name.changed.connect(sigc::mem_fun(this, &Model<RowAdaptor>::OnSwarmNameChanged));
   count.SetGetterFunction(sigc::mem_fun(this, &Model<RowAdaptor>::get_count));
   seqnum.SetGetterFunction(sigc::mem_fun(this, &Model<RowAdaptor>::get_seqnum));
+  model.SetGetterFunction(sigc::mem_fun(this, &Model<RowAdaptor>::get_model));
 }
 
 template<class RowAdaptor>
@@ -52,7 +70,29 @@
   if (model_)
     dee_model_clear(model_);
 
-  model_ = dee_shared_model_new(swarm_name.c_str());
+  switch(model_type_)
+  {
+    case ModelType::LOCAL:
+      model_ = dee_sequence_model_new();
+      break;
+    case ModelType::REMOTE:
+      model_ = dee_shared_model_new(swarm_name.c_str());
+      sig_manager_.Add(new TransactionSignalType(model_,
+                                                 "begin-transaction",
+                                                 sigc::mem_fun(this, &Model<RowAdaptor>::OnTransactionBegin)));
+
+      sig_manager_.Add(new TransactionSignalType(model_,
+                                                 "end-transaction",
+                                                 sigc::mem_fun(this, &Model<RowAdaptor>::OnTransactionEnd)));
+      break;
+    default:
+      LOG_ERROR(_model_inl_logger) <<  "Unexpected ModelType " << model_type_;
+      break;
+  }
+
+  model.EmitChanged(model_);
+
+
   renderer_tag_ = dee_model_register_tag(model_, NULL);
 
   sig_manager_.Add(new RowSignalType(model_,
@@ -66,14 +106,6 @@
   sig_manager_.Add(new RowSignalType(model_,
                                      "row-removed",
                                      sigc::mem_fun(this, &Model<RowAdaptor>::OnRowRemoved)));
-
-  sig_manager_.Add(new TransactionSignalType(model_,
-                                             "begin-transaction",
-                                             sigc::mem_fun(this, &Model<RowAdaptor>::OnTransactionBegin)));
-
-  sig_manager_.Add(new TransactionSignalType(model_,
-                                             "end-transaction",
-                                             sigc::mem_fun(this, &Model<RowAdaptor>::OnTransactionEnd)));
 }
 
 template<class RowAdaptor>
@@ -148,6 +180,12 @@
     return 0;
 }
 
+template<class RowAdaptor>
+glib::Object<DeeModel> Model<RowAdaptor>::get_model()
+{
+  return model_;
+}
+
 }
 }
 
 
=== modified file 'UnityCore/Model.h'
--- UnityCore/Model.h	2012-01-10 14:14:17 +0000
+++ UnityCore/Model.h	2012-01-26 08:37:26 +0000
@@ -35,6 +35,12 @@
 namespace dash
 {
 
+enum ModelType
+{
+  REMOTE,
+  LOCAL
+};
+
 /* This template class encapsulates the basics of talking to a DeeSharedModel,
  * however it is a template as you can choose your own RowAdaptor (see
  * ResultsRowAdaptor.h for an example) which then presents the data in the rows
@@ -47,6 +53,7 @@
   typedef std::shared_ptr<Model> Ptr;
 
   Model();
+  Model (ModelType model_type);
   virtual ~Model();
 
   const RowAdaptor RowAtIndex(std::size_t index);
@@ -54,6 +61,7 @@
   nux::Property<std::string> swarm_name;
   nux::ROProperty<std::size_t> count;
   nux::ROProperty<unsigned long long> seqnum;
+  nux::ROProperty<glib::Object<DeeModel>> model;
 
   sigc::signal<void, RowAdaptor&> row_added;
   sigc::signal<void, RowAdaptor&> row_changed;
@@ -63,6 +71,7 @@
   sigc::signal<void, unsigned long long, unsigned long long> end_transaction;
 
 private:
+  void Init();
   void OnRowAdded(DeeModel* model, DeeModelIter* iter);
   void OnRowChanged(DeeModel* model, DeeModelIter* iter);
   void OnRowRemoved(DeeModel* model, DeeModelIter* iter);
@@ -71,11 +80,13 @@
   void OnSwarmNameChanged(std::string const& swarm_name);
   std::size_t get_count();
   unsigned long long get_seqnum();
+  glib::Object<DeeModel> get_model();
 
 private:
   glib::Object<DeeModel> model_;
   glib::SignalManager sig_manager_;
   DeeModelTag* renderer_tag_;
+  ModelType model_type_;
 };
 
 }
 
=== modified file 'UnityCore/Results.cpp'
--- UnityCore/Results.cpp	2011-07-25 10:54:25 +0000
+++ UnityCore/Results.cpp	2012-01-26 08:37:26 +0000
@@ -31,6 +31,14 @@
   row_removed.connect(sigc::mem_fun(this, &Results::OnRowRemoved));
 }
 
+Results::Results(ModelType model_type)
+  : Model<Result>::Model(model_type)
+{
+  row_added.connect(sigc::mem_fun(this, &Results::OnRowAdded));
+  row_changed.connect(sigc::mem_fun(this, &Results::OnRowChanged));
+  row_removed.connect(sigc::mem_fun(this, &Results::OnRowRemoved));
+}
+
 void Results::OnRowAdded(Result& result)
 {
   result_added.emit(result);
 
=== modified file 'UnityCore/Results.h'
--- UnityCore/Results.h	2011-07-28 13:35:05 +0000
+++ UnityCore/Results.h	2012-01-26 08:37:26 +0000
@@ -36,6 +36,7 @@
   typedef std::shared_ptr<Results> Ptr;
 
   Results();
+  Results(ModelType model_type);
 
   sigc::signal<void, Result const&> result_added;
   sigc::signal<void, Result const&> result_changed;
 
=== modified file 'com.canonical.Unity.gschema.xml'
--- com.canonical.Unity.gschema.xml	2011-12-12 18:18:38 +0000
+++ com.canonical.Unity.gschema.xml	2012-01-26 08:37:26 +0000
@@ -21,7 +21,7 @@
       <description>Whether the home screen should be expanded.</description>
     </key>
   </schema>
-	<schema path="/desktop/unity/launcher/" id="com.canonical.Unity.Launcher" gettext-domain="unity">
+  <schema path="/desktop/unity/launcher/" id="com.canonical.Unity.Launcher" gettext-domain="unity">
     <key type="as" name="favorites">
       <default>[ 'ubiquity-gtkui.desktop', 'nautilus-home.desktop', 'firefox.desktop', 'libreoffice-writer.desktop', 'libreoffice-calc.desktop', 'libreoffice-impress.desktop', 'ubuntu-software-center.desktop', 'ubuntuone-installer.desktop', 'gnome-control-center.desktop' ]</default>
       <summary>List of desktop file ids for favorites on the launcher.</summary>
@@ -33,7 +33,7 @@
       <description>This is a detection key for the favorite migration script to know whether the needed migration is done or not.</description>
     </key>
   </schema>
-	<schema path="/desktop/unity/panel/" id="com.canonical.Unity.Panel" gettext-domain="unity">
+  <schema path="/desktop/unity/panel/" id="com.canonical.Unity.Panel" gettext-domain="unity">
     <key type="as" name="systray-whitelist">
       <default>[ 'JavaEmbeddedFrame', 'Wine', 'scp-dbus-service', 'Update-notifier' ]</default>
       <summary>List of client names, resource classes or wm classes to allow in the Panel's systray implementation.</summary>
@@ -46,5 +46,12 @@
         <summary>List of device uuid for favorites on the launcher.</summary>
         <description>These devices are shown in the Launcher by default.</description>
     </key>
-    </schema>
+  </schema>
+  <schema path="/desktop/unity/dash/" id="com.canonical.Unity.Dash" gettext-domain="unity">
+    <key type="as" name="home-lens-ordering">
+      <default>[ 'applications.lens', 'files.lens', 'music.lens' ]</default>
+      <summary>List of lens ids specifying how lenses should be ordered in the Dash home screen.</summary>
+      <description>The categories listed on the Dash home screen will be ordered according to this list. Lenses not appearing in this list will not have any particular ordering and will always sort after lenses specified in this list.</description>
+    </key>
+  </schema>
 </schemalist>
 
=== modified file 'plugins/unityshell/src/DashView.cpp'
--- plugins/unityshell/src/DashView.cpp	2012-01-17 13:31:52 +0000
+++ plugins/unityshell/src/DashView.cpp	2012-01-26 08:37:26 +0000
@@ -47,6 +47,7 @@
 
 DashView::DashView()
   : nux::View(NUX_TRACKER_LOCATION)
+  , home_lens_(new HomeLens(_("Home"), _("Home screen"), _("Search")))
   , active_lens_view_(0)
   , last_activated_uri_("")
   , searching_timeout_id_(0)
@@ -67,6 +68,8 @@
   mouse_down.connect(sigc::mem_fun(this, &DashView::OnMouseButtonDown));
 
   Relayout();
+
+  home_lens_->AddLenses(lenses_);
   lens_bar_->Activate("home.lens");
 }
 
@@ -81,6 +84,23 @@
   ubus_manager_.SendMessage(UBUS_BACKGROUND_REQUEST_COLOUR_EMIT);
   visible_ = true;
   search_bar_->text_entry()->SelectAll();
+
+  /* Give the lenses a chance to prep data before we map them  */
+  lens_bar_->Activate(active_lens_view_->lens()->id());
+  if (active_lens_view_->lens()->id() == "home.lens")
+  {
+    for (auto lens : lenses_.GetLenses())
+      {
+        lens->view_type = ViewType::HOME_VIEW;
+        LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HOME_VIEW
+                              << " on '" << lens->id() << "'";
+      }
+
+      home_lens_->view_type = ViewType::LENS_VIEW;
+      LOG_DEBUG(logger) << "Setting ViewType " << ViewType::LENS_VIEW
+                                << " on '" << home_lens_->id() << "'";
+  }
+
   renderer_.AboutToShow();
 }
 
@@ -88,6 +108,17 @@
 {
   visible_ = false;
   renderer_.AboutToHide();
+
+  for (auto lens : lenses_.GetLenses())
+  {
+    lens->view_type = ViewType::HIDDEN;
+    LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HIDDEN
+                          << " on '" << lens->id() << "'";
+  }
+
+  home_lens_->view_type = ViewType::HIDDEN;
+  LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HIDDEN
+                            << " on '" << home_lens_->id() << "'";
 }
 
 void DashView::SetupViews()
@@ -111,9 +142,9 @@
   lenses_layout_ = new nux::VLayout();
   content_layout_->AddView(lenses_layout_, 1, nux::MINOR_POSITION_LEFT);
 
-  home_view_ = new HomeView();
+  home_view_ = new LensView(home_lens_);
   active_lens_view_ = home_view_;
-  lens_views_["home.lens"] = home_view_;
+  lens_views_[home_lens_->id] = home_view_;
   lenses_layout_->AddView(home_view_);
 
   lens_bar_ = new LensBar();
@@ -239,7 +270,6 @@
 
   std::string id = AnalyseLensURI(uri.Str());
 
-  home_view_->search_string = "";
   lens_bar_->Activate(id);
 
   if ((id == "home.lens" && handled_type != GOTO_DASH_URI ) || !visible_)
@@ -336,7 +366,6 @@
 {
   std::string id = lens->id;
   lens_bar_->AddLens(lens);
-  home_view_->AddLens(lens);
 
   LensView* view = new LensView(lens);
   view->SetVisible(false);
@@ -362,15 +391,17 @@
   for (auto it: lens_views_)
   {
     bool id_matches = it.first == id;
+    ViewType view_type = id_matches ? LENS_VIEW : (view == home_view_ ? HOME_VIEW : HIDDEN);
     it.second->SetVisible(id_matches);
-    it.second->view_type = id_matches ? LENS_VIEW : (view == home_view_ ? HOME_VIEW : HIDDEN);
+    it.second->view_type = view_type;
+
+    LOG_DEBUG(logger) << "Setting ViewType " << view_type
+                      << " on '" << it.first << "'";
   }
 
   search_bar_->search_string = view->search_string;
-  if (view != home_view_)
-    search_bar_->search_hint = view->lens()->search_hint;
-  else
-    search_bar_->search_hint = _("Search");
+  search_bar_->search_hint = view->lens()->search_hint;
+
   bool expanded = view->filters_expanded;
   search_bar_->showing_filters = expanded;
 
@@ -553,6 +584,7 @@
       ubus_manager_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
     else
       search_bar_->search_string = "";
+
     return true;
   }
   return false;
 
=== modified file 'plugins/unityshell/src/DashView.h'
--- plugins/unityshell/src/DashView.h	2012-01-16 15:31:59 +0000
+++ plugins/unityshell/src/DashView.h	2012-01-26 08:37:26 +0000
@@ -27,10 +27,10 @@
 #include <Nux/View.h>
 #include <Nux/VLayout.h>
 #include <UnityCore/FilesystemLenses.h>
+#include <UnityCore/HomeLens.h>
 
 #include "BackgroundEffectHelper.h"
 #include "DashSearchBar.h"
-#include "HomeView.h"
 #include "Introspectable.h"
 #include "LensBar.h"
 #include "LensView.h"
@@ -95,6 +95,7 @@
   std::string AnalyseLensURI(std::string const& uri);
   void UpdateLensFilter(std::string lens, std::string filter, std::string value);
   void UpdateLensFilterValue(Filter::Ptr filter, std::string value);
+  void EnsureLensesInitialized();
 
   bool AcceptKeyNavFocus();
   bool InspectKeyEvent(unsigned int eventType, unsigned int key_sym, const char* character);
@@ -108,6 +109,7 @@
 private:
   UBusManager ubus_manager_;
   FilesystemLenses lenses_;
+  HomeLens::Ptr home_lens_;
   LensViews lens_views_;
 
 
@@ -118,7 +120,7 @@
   nux::VLayout* lenses_layout_;
   LensBar* lens_bar_;
 
-  HomeView* home_view_;
+  LensView* home_view_;
   LensView* active_lens_view_;
 
   // Drawing related
 
=== removed file 'plugins/unityshell/src/HomeView.cpp'
--- plugins/unityshell/src/HomeView.cpp	2011-12-21 16:49:59 +0000
+++ plugins/unityshell/src/HomeView.cpp	1970-01-01 00:00:00 +0000
@@ -1,252 +0,0 @@
-/*
- * Copyright (C) 2010 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 "HomeView.h"
-
-#include <boost/lexical_cast.hpp>
-
-#include <NuxCore/Logger.h>
-
-#include "DashStyle.h"
-#include "ResultRendererTile.h"
-#include "UBusMessages.h"
-
-namespace unity
-{
-namespace dash
-{
-
-namespace
-{
-nux::logging::Logger logger("unity.dash.homeview");
-}
-
-// This is so we can override the scroll bar for the view.
-class HomeScrollView: public nux::ScrollView
-{
-public:
-  HomeScrollView(nux::VScrollBar* scroll_bar, NUX_FILE_LINE_DECL)
-    : nux::ScrollView(NUX_FILE_LINE_PARAM)
-  {
-    SetVScrollBar(scroll_bar);
-  }
-};
-
-
-
-NUX_IMPLEMENT_OBJECT_TYPE(HomeView);
-
-HomeView::HomeView()
-  : fix_renderering_id_(0)
-{
-  SetupViews();
-
-  search_string.changed.connect([&](std::string const& search)
-  {
-    for (auto lens : lenses_)
-      lens->GlobalSearch(search);
-
-    for (auto group: categories_)
-    {
-      group->SetVisible(search != "" && counts_[group]);
-    }
-    home_view_->SetVisible(search == "");
-    scroll_view_->SetVisible(search != "");
-
-    QueueDraw();
-  });
-}
-
-HomeView::~HomeView()
-{
-  if (fix_renderering_id_)
-    g_source_remove(fix_renderering_id_);
-}
-
-void HomeView::SetupViews()
-{
-  layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
-  layout_->SetHorizontalExternalMargin(7);
-
-  scroll_view_ = new HomeScrollView(new PlacesVScrollBar(NUX_TRACKER_LOCATION),
-                                    NUX_TRACKER_LOCATION);
-  scroll_view_->EnableVerticalScrollBar(true);
-  scroll_view_->EnableHorizontalScrollBar(false);
-  scroll_view_->SetVisible(false);
-  layout_->AddView(scroll_view_);
-
-  scroll_layout_ = new nux::VLayout();
-  scroll_view_->SetLayout(scroll_layout_);
-
-  home_view_ = new PlacesHomeView();
-  layout_->AddView(home_view_);
-
-  SetLayout(layout_);
-}
-
-void HomeView::AddLens(Lens::Ptr lens)
-{
-  lenses_.push_back(lens);
-
-  std::string name = lens->name;
-  std::string icon_hint = lens->icon_hint;
-
-  LOG_DEBUG(logger) << "Lens added " << name;
-
-  PlacesGroup* group = new PlacesGroup();
-  group->SetName(name.c_str());
-  group->SetIcon(icon_hint.c_str());
-  group->SetExpanded(false);
-  group->SetVisible(false);
-  group->expanded.connect(sigc::mem_fun(this, &HomeView::OnGroupExpanded));
-  categories_.push_back(group);
-  counts_[group] = 0;
-
-  ResultViewGrid* grid = new ResultViewGrid(NUX_TRACKER_LOCATION);
-  grid->expanded = false;
-  grid->SetModelRenderer(new ResultRendererTile(NUX_TRACKER_LOCATION));
-  grid->UriActivated.connect([&, lens] (std::string const& uri) { uri_activated.emit(uri); lens->Activate(uri); });
-  group->SetChildView(grid);
-
-  Results::Ptr results = lens->global_results;
-  results->result_added.connect([&, group, grid] (Result const& result)
-  {
-    grid->AddResult(const_cast<Result&>(result));
-    counts_[group]++;
-    UpdateCounts(group);
-  });
-
-  results->result_removed.connect([&, group, grid] (Result const& result)
-  {
-    grid->RemoveResult(const_cast<Result&>(result));
-    counts_[group]--;
-    UpdateCounts(group);
-  });
-
-
-  scroll_layout_->AddView(group, 0);
-}
-
-void HomeView::UpdateCounts(PlacesGroup* group)
-{
-  group->SetCounts(dash::Style::Instance().GetDefaultNColumns(), counts_[group]);
-  group->SetVisible(counts_[group]);
-
-  QueueFixRenderering();
-}
-
-void HomeView::OnGroupExpanded(PlacesGroup* group)
-{
-  ResultViewGrid* grid = static_cast<ResultViewGrid*>(group->GetChildView());
-  grid->expanded = group->GetExpanded();
-  ubus_manager_.SendMessage(UBUS_PLACE_VIEW_QUEUE_DRAW);
-}
-
-void HomeView::OnColumnsChanged()
-{
-  unsigned int columns = dash::Style::Instance().GetDefaultNColumns();
-
-  for (auto group: categories_)
-  {
-    group->SetCounts(columns, counts_[group]);
-  }
-}
-
-void HomeView::QueueFixRenderering()
-{
-  if (fix_renderering_id_)
-    return;
-
-  fix_renderering_id_ = g_idle_add_full (G_PRIORITY_DEFAULT, (GSourceFunc)FixRenderering, this, NULL);
-}
-
-gboolean HomeView::FixRenderering(HomeView* self)
-{
-  std::list<Area*> children = self->scroll_layout_->GetChildren();
-  std::list<Area*>::reverse_iterator rit;
-  bool found_one = false;
-
-  for (rit = children.rbegin(); rit != children.rend(); ++rit)
-  {
-    PlacesGroup* group = static_cast<PlacesGroup*>(*rit);
-
-    if (group->IsVisible())
-      group->SetDrawSeparator(found_one);
-
-    found_one = group->IsVisible();
-  }
-
-  self->fix_renderering_id_ = 0;
-  return FALSE;
-}
-
-void HomeView::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
-{
-  nux::Geometry geo = GetGeometry();
-
-  gfx_context.PushClippingRectangle(geo);
-  nux::GetPainter().PaintBackground(gfx_context, geo);
-  gfx_context.PopClippingRectangle();
-}
-
-void HomeView::DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw)
-{
-  gfx_context.PushClippingRectangle(GetGeometry());
-
-  layout_->ProcessDraw(gfx_context, force_draw);
-
-  gfx_context.PopClippingRectangle();
-}
-
-void HomeView::ActivateFirst()
-{
-  for (auto lens: lenses_)
-  {
-    Results::Ptr results = lens->global_results;
-    if (results->count())
-    {
-      Result result = results->RowAtIndex(0);
-      if (result.uri != "")
-      {
-        uri_activated(result.uri);
-        lens->Activate(result.uri);
-        return;
-      }
-    }
-  }
-}
-
-
-// Keyboard navigation
-bool HomeView::AcceptKeyNavFocus()
-{
-  return false;
-}
-
-// Introspectable
-std::string HomeView::GetName() const
-{
-  return "HomeView";
-}
-
-void HomeView::AddProperties(GVariantBuilder* builder)
-{}
-
-
-}
-}
 
=== removed file 'plugins/unityshell/src/HomeView.h'
--- plugins/unityshell/src/HomeView.h	2011-12-16 01:55:42 +0000
+++ plugins/unityshell/src/HomeView.h	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2010 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_HOME_VIEW_H_
-#define UNITY_HOME_VIEW_H_
-
-#include <string>
-
-#include <NuxGraphics/GraphicsEngine.h>
-#include <Nux/Nux.h>
-#include <Nux/HLayout.h>
-#include <Nux/View.h>
-#include <Nux/VLayout.h>
-#include <UnityCore/Lens.h>
-
-#include "LensView.h"
-#include "PlacesGroup.h"
-#include "PlacesHomeView.h"
-#include "ResultViewGrid.h"
-#include "UBusWrapper.h"
-
-namespace unity
-{
-namespace dash
-{
-
-class HomeView : public LensView
-{
-  NUX_DECLARE_OBJECT_TYPE(HomeView, LensView);
-  typedef std::vector<PlacesGroup*> CategoryGroups;
-  typedef std::map<PlacesGroup*, unsigned int> ResultCounts;
-  typedef std::vector<Lens::Ptr> Lenses;
-
-public:
-  HomeView();
-  ~HomeView();
-
-  void AddLens(Lens::Ptr lens);
-  void ActivateFirst();
-
-private:
-  void SetupViews();
-
-  void OnResultAdded(Result const& result);
-  void OnResultRemoved(Result const& result);
-  void UpdateCounts(PlacesGroup* group);
-  void OnGroupExpanded(PlacesGroup* group);
-  void OnColumnsChanged();
-  void QueueFixRenderering();
-
-  static gboolean FixRenderering(HomeView* self);
-
-  void Draw(nux::GraphicsEngine& gfx_context, bool force_draw);
-  void DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw);
-  
-  bool AcceptKeyNavFocus();
-  std::string GetName() const;
-  void AddProperties(GVariantBuilder* builder);
-
-private:
-  UBusManager ubus_manager_;
-  CategoryGroups categories_;
-  ResultCounts counts_;
-  Lenses lenses_;
-
-  nux::HLayout* layout_;
-  nux::ScrollView* scroll_view_;
-  nux::VLayout* scroll_layout_;
-
-  PlacesHomeView* home_view_;
-
-  guint fix_renderering_id_;
-};
-
-
-}
-}
-#endif
 
=== modified file 'plugins/unityshell/src/LensBar.cpp'
--- plugins/unityshell/src/LensBar.cpp	2011-12-08 01:23:11 +0000
+++ plugins/unityshell/src/LensBar.cpp	2012-01-26 08:37:26 +0000
@@ -148,10 +148,20 @@
 
 void LensBar::SetActive(LensBarIcon* activated)
 {
+  bool state_changed = false;
+
   for (auto icon: icons_)
-    icon->active = icon == activated;
-
-  lens_activated.emit(activated->id);
+  {
+    bool state = icon == activated;
+
+    if (icon->active != state)
+      state_changed = true;
+
+    icon->active = state;
+  }
+
+  if (state_changed)
+    lens_activated.emit(activated->id);
 }
 
 void LensBar::ActivateNext()
 
=== modified file 'plugins/unityshell/src/LensView.cpp'
--- plugins/unityshell/src/LensView.cpp	2011-12-14 16:18:41 +0000
+++ plugins/unityshell/src/LensView.cpp	2012-01-26 08:37:26 +0000
@@ -219,7 +219,12 @@
   group->SetExpanded(false);
   group->SetVisible(false);
   group->expanded.connect(sigc::mem_fun(this, &LensView::OnGroupExpanded));
-  categories_.push_back(group);
+
+
+  /* Add the group at the correct offset into the categories vector */
+  categories_.insert(categories_.begin() + index, group);
+
+  /* Reset result count */
   counts_[group] = 0;
 
   ResultViewGrid* grid = new ResultViewGrid(NUX_TRACKER_LOCATION);
@@ -232,7 +237,11 @@
   grid->UriActivated.connect([&] (std::string const& uri) { uri_activated.emit(uri); lens_->Activate(uri); });
   group->SetChildView(grid);
 
-  scroll_layout_->AddView(group, 0);
+  /* We need the full range of method args so we can specify the offset
+   * of the group into the layout */
+  scroll_layout_->AddView(group, 0, nux::MinorDimensionPosition::eAbove,
+                          nux::MinorDimensionSize::eFull, 100.0f,
+                          (nux::LayoutPosition)index);
 }
 
 void LensView::OnResultAdded(Result const& result)
 
=== removed file 'plugins/unityshell/src/PlacesHomeView.cpp'
--- plugins/unityshell/src/PlacesHomeView.cpp	2011-12-14 20:04:23 +0000
+++ plugins/unityshell/src/PlacesHomeView.cpp	1970-01-01 00:00:00 +0000
@@ -1,378 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2010 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 "config.h"
-
-#include <Nux/Nux.h>
-#include <Nux/BaseWindow.h>
-#include <Nux/HLayout.h>
-#include <Nux/Layout.h>
-#include <Nux/WindowCompositor.h>
-
-#include <NuxImage/CairoGraphics.h>
-#include <NuxImage/ImageSurface.h>
-
-#include <NuxGraphics/GLThread.h>
-#include <NuxGraphics/RenderingPipe.h>
-
-#include <glib.h>
-#include <glib/gi18n-lib.h>
-#include <gio/gdesktopappinfo.h>
-#include "ubus-server.h"
-#include "UBusMessages.h"
-
-#include "PlacesHomeView.h"
-#include "PlacesSimpleTile.h"
-
-#include "DashStyle.h"
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/Variant.h>
-
-#include <string>
-#include <vector>
-
-#define DELTA_DOUBLE_REQUEST 500000000
-
-namespace unity
-{
-
-enum
-{
-  TYPE_PLACE = 0,
-  TYPE_EXEC
-};
-
-class Shortcut : public PlacesSimpleTile
-{
-public:
-  Shortcut(const char* icon, const char* name, int size)
-    : PlacesSimpleTile(icon, name, size),
-      _id(0),
-      _place_id(NULL),
-      _place_section(0),
-      _exec(NULL)
-  {
-    SetDndEnabled(false, false);
-  }
-
-  ~Shortcut()
-  {
-    g_free(_place_id);
-    g_free(_exec);
-  }
-
-  int      _id;
-  gchar*   _place_id;
-  guint32  _place_section;
-  char*    _exec;
-};
-
-PlacesHomeView::PlacesHomeView()
-  : _ubus_handle(0)
-{
-  dash::Style& style = dash::Style::Instance();
-
-  SetName(_("Shortcuts"));
-  SetIcon(PKGDATADIR"/shortcuts_group_icon.png");
-  SetDrawSeparator(false);
-
-  _layout = new nux::GridHLayout(NUX_TRACKER_LOCATION);
-  _layout->SetReconfigureParentLayoutOnGeometryChange(true);
-  SetChildLayout(_layout);
-
-  _layout->ForceChildrenSize(true);
-  _layout->SetChildrenSize(style.GetHomeTileWidth(), style.GetHomeTileHeight());
-  _layout->EnablePartialVisibility(false);
-  _layout->MatchContentSize(true);
-  _layout->SetLeftAndRightPadding(32);
-  _layout->SetSpaceBetweenChildren(32, 32);
-  _layout->SetMinMaxSize((style.GetHomeTileWidth() * 4) + (32 * 5),
-                         (style.GetHomeTileHeight() * 2) + 32);
-
-  _ubus_handle = ubus_server_register_interest(ubus_server_get_default(),
-                                               UBUS_PLACE_VIEW_SHOWN,
-                                               (UBusCallback) &PlacesHomeView::DashVisible,
-                                               this);
-
-  //In case the GConf key is invalid (e.g. when an app was uninstalled), we
-  //rely on a fallback "whitelist" mechanism instead of showing nothing at all
-  _browser_alternatives.push_back("firefox");
-  _browser_alternatives.push_back("chromium-browser");
-  _browser_alternatives.push_back("epiphany-browser");
-  _browser_alternatives.push_back("midori");
-
-  _photo_alternatives.push_back("shotwell");
-  _photo_alternatives.push_back("f-spot");
-  _photo_alternatives.push_back("gthumb");
-  _photo_alternatives.push_back("gwenview");
-  _photo_alternatives.push_back("eog");
-
-  _email_alternatives.push_back("evolution");
-  _email_alternatives.push_back("thunderbird");
-  _email_alternatives.push_back("claws-mail");
-  _email_alternatives.push_back("kmail");
-
-  _music_alternatives.push_back("banshee-1");
-  _music_alternatives.push_back("rhythmbox");
-  _music_alternatives.push_back("totem");
-  _music_alternatives.push_back("vlc");
-
-  expanded.connect(sigc::mem_fun(this, &PlacesHomeView::Refresh));
-
-  Refresh();
-}
-
-PlacesHomeView::~PlacesHomeView()
-{
-  if (_ubus_handle != 0)
-    ubus_server_unregister_interest(ubus_server_get_default(), _ubus_handle);
-}
-
-void
-PlacesHomeView::DashVisible(GVariant* data, void* val)
-{
-  PlacesHomeView* self = (PlacesHomeView*)val;
-  self->Refresh();
-}
-
-void
-PlacesHomeView::Refresh(PlacesGroup*foo)
-{
-  Shortcut*   shortcut = NULL;
-  gchar*      markup = NULL;
-  const char* temp = "<big>%s</big>";
-  int         icon_size = dash::Style::Instance().GetHomeTileIconSize();
-
-  _layout->Clear();
-
-  // Media Apps
-  markup = g_strdup_printf(temp, _("Media Apps"));
-  shortcut = new Shortcut(PKGDATADIR"/find_media_apps.png",
-                          markup,
-                          icon_size);
-  shortcut->_id = TYPE_PLACE;
-  shortcut->_place_id = g_strdup("applications.lens?filter_type=media");
-  shortcut->_place_section = 9;
-  _layout->AddView(shortcut, 1, nux::eLeft, nux::eFull);
-  shortcut->sigClick.connect(sigc::mem_fun(this, &PlacesHomeView::OnShortcutClicked));
-  g_free(markup);
-
-  // Internet Apps
-  markup = g_strdup_printf(temp, _("Internet Apps"));
-  shortcut = new Shortcut(PKGDATADIR"/find_internet_apps.png",
-                          markup,
-                          icon_size);
-  shortcut->_id = TYPE_PLACE;
-  shortcut->_place_id = g_strdup("applications.lens?filter_type=internet");
-  shortcut->_place_section = 8;
-  _layout->AddView(shortcut, 1, nux::eLeft, nux::eFull);
-  shortcut->sigClick.connect(sigc::mem_fun(this, &PlacesHomeView::OnShortcutClicked));
-  g_free(markup);
-
-  // More Apps
-  markup = g_strdup_printf(temp, _("More Apps"));
-  shortcut = new Shortcut(PKGDATADIR"/find_more_apps.png",
-                          markup,
-                          icon_size);
-  shortcut->_id = TYPE_PLACE;
-  shortcut->_place_id = g_strdup("applications.lens");
-  shortcut->_place_section = 0;
-  _layout->AddView(shortcut, 1, nux::eLeft, nux::eFull);
-  shortcut->sigClick.connect(sigc::mem_fun(this, &PlacesHomeView::OnShortcutClicked));
-  g_free(markup);
-
-  // Find Files
-  markup = g_strdup_printf(temp, _("Find Files"));
-  shortcut = new Shortcut(PKGDATADIR"/find_files.png",
-                          markup,
-                          icon_size);
-  shortcut->_id = TYPE_PLACE;
-  shortcut->_place_id = g_strdup("files.lens");
-  shortcut->_place_section = 0;
-  _layout->AddView(shortcut, 1, nux::eLeft, nux::eFull);
-  shortcut->sigClick.connect(sigc::mem_fun(this, &PlacesHomeView::OnShortcutClicked));
-  g_free(markup);
-
-  // Browser
-  CreateShortcutFromMime("x-scheme-handler/http", _("Browse the Web"), _browser_alternatives);
-
-  // Photos
-  // FIXME: Need to figure out the default
-  CreateShortcutFromExec("shotwell", _("View Photos"), _photo_alternatives);
-
-  CreateShortcutFromMime("x-scheme-handler/mailto", _("Check Email"), _email_alternatives);
-
-  CreateShortcutFromMime("audio/x-vorbis+ogg", _("Listen to Music"), _music_alternatives);
-
-  SetExpanded(true);
-  SetCounts(8, 8);
-
-  QueueDraw();
-  _layout->QueueDraw();
-  QueueRelayout();
-}
-
-void
-PlacesHomeView::CreateShortcutFromExec(const char* exec,
-                                       const char* name,
-                                       std::vector<std::string>& alternatives)
-{
-  dash::Style&     style = dash::Style::Instance();
-  Shortcut*        shortcut = NULL;
-  gchar*           id;
-  gchar*           markup;
-  gchar*           icon;
-  gchar*           real_exec;
-  GDesktopAppInfo* info;
-
-  markup = g_strdup_printf("<big>%s</big>", name);
-
-  // We're going to try and create a desktop id from a exec string. Now, this is hairy at the
-  // best of times but the following is the closest best-guess without having to do D-Bus
-  // roundtrips to BAMF.
-  if (exec)
-  {
-    char* basename;
-
-    if (exec[0] == '/')
-      basename = g_path_get_basename(exec);
-    else
-      basename = g_strdup(exec);
-
-    id = g_strdup_printf("%s.desktop", basename);
-
-    g_free(basename);
-  }
-  else
-  {
-    id = g_strdup_printf("%s.desktop", alternatives[0].c_str());
-  }
-
-  info = g_desktop_app_info_new(id);
-  std::vector<std::string>::iterator iter = alternatives.begin();
-  while (iter != alternatives.end())
-  {
-    if (!G_IS_DESKTOP_APP_INFO(info))
-    {
-      id = g_strdup_printf("%s.desktop", (*iter).c_str());
-      info = g_desktop_app_info_new(id);
-      iter++;
-    }
-
-    if (G_IS_DESKTOP_APP_INFO(info))
-    {
-      icon = g_icon_to_string(g_app_info_get_icon(G_APP_INFO(info)));
-      real_exec = g_strdup(g_app_info_get_executable(G_APP_INFO(info)));
-
-      shortcut = new Shortcut(icon, markup, style.GetHomeTileIconSize());
-      shortcut->_id = TYPE_EXEC;
-      shortcut->_exec = real_exec;
-      _layout->AddView(shortcut, 1, nux::eLeft, nux::eFull);
-      shortcut->sigClick.connect(sigc::mem_fun(this, &PlacesHomeView::OnShortcutClicked));
-
-      g_free(icon);
-
-      break;
-    }
-  }
-
-  g_free(id);
-  g_free(markup);
-}
-
-void PlacesHomeView::CreateShortcutFromMime(const char* mime,
-                                            const char* name,
-                                            std::vector<std::string>& alternatives)
-{
-  dash::Style& style = dash::Style::Instance();
-  GAppInfo* info = g_app_info_get_default_for_type(mime, FALSE);
-
-  // If it was invalid check alternatives for backup
-  if (!G_IS_DESKTOP_APP_INFO(info))
-  {
-    for (auto alt: alternatives)
-    {
-      std::string id = alt + ".desktop";
-      info = G_APP_INFO(g_desktop_app_info_new(id.c_str()));
-      
-      if (G_IS_DESKTOP_APP_INFO(info))
-        break;
-    }
-  }
-
-  if (G_IS_DESKTOP_APP_INFO(info))
-  {
-    glib::String icon(g_icon_to_string(g_app_info_get_icon(G_APP_INFO(info))));
-    glib::String markup(g_strdup_printf("<big>%s</big>", name));
-    
-    Shortcut*   shortcut = new Shortcut(icon.Value(), markup.Value(), style.GetHomeTileIconSize());
-    shortcut->_id = TYPE_EXEC;
-    shortcut->_exec = g_strdup (g_app_info_get_executable(G_APP_INFO(info)));;
-    shortcut->sigClick.connect(sigc::mem_fun(this, &PlacesHomeView::OnShortcutClicked));
-    _layout->AddView(shortcut, 1, nux::eLeft, nux::eFull);
-
-    g_object_unref(info);
-  }
-}
-
-void
-PlacesHomeView::OnShortcutClicked(PlacesTile* tile)
-{
-  Shortcut* shortcut = static_cast<Shortcut*>(tile);
-  int id = shortcut->_id;
-
-  if (id == TYPE_PLACE)
-  {
-    ubus_server_send_message(ubus_server_get_default(),
-                             UBUS_PLACE_ENTRY_ACTIVATE_REQUEST,
-                             g_variant_new("(sus)",
-                                           shortcut->_place_id,
-                                           shortcut->_place_section,
-                                           ""));
-  }
-  else if (id == TYPE_EXEC)
-  {
-    GError* error = NULL;
-
-    if (!g_spawn_command_line_async(shortcut->_exec, &error))
-    {
-      g_warning("%s: Unable to launch %s: %s",
-                G_STRFUNC,
-                shortcut->_exec,
-                error->message);
-      g_error_free(error);
-    }
-
-    ubus_server_send_message(ubus_server_get_default(),
-                             UBUS_PLACE_VIEW_CLOSE_REQUEST,
-                             NULL);
-  }
-}
-
-std::string PlacesHomeView::GetName() const
-{
-  return "PlacesHomeView";
-}
-
-void PlacesHomeView::AddProperties(GVariantBuilder* builder)
-{
-  unity::variant::BuilderWrapper(builder).add(GetGeometry());
-}
-
-} // namespace unity
 
=== removed file 'plugins/unityshell/src/PlacesHomeView.h'
--- plugins/unityshell/src/PlacesHomeView.h	2011-12-14 20:04:23 +0000
+++ plugins/unityshell/src/PlacesHomeView.h	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2010 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 PLACES_HOME_VIEW_H
-#define PLACES_HOME_VIEW_H
-
-#include <Nux/View.h>
-#include <Nux/Layout.h>
-#include <Nux/TextureArea.h>
-#include <NuxGraphics/GraphicsEngine.h>
-
-#include "Introspectable.h"
-
-#include <Nux/GridHLayout.h>
-
-#include "PlacesTile.h"
-#include "PlacesGroup.h"
-
-namespace unity
-{
-
-class PlacesHomeView : public unity::debug::Introspectable, public PlacesGroup
-{
-public:
-  PlacesHomeView();
-  ~PlacesHomeView();
-
-  void Refresh(PlacesGroup* foo =NULL);
-
-protected:
-  // Introspectable methods
-  std::string GetName() const;
-  void AddProperties(GVariantBuilder* builder);
-
-private:
-  static void DashVisible(GVariant* data, void* val);
-  void OnShortcutClicked(PlacesTile* _tile);
-  void CreateShortcutFromExec(const char* exec,
-                              const char* name,
-                              std::vector<std::string>& alternatives);
-  void CreateShortcutFromMime(const char* mime,
-                              const char* name,
-                              std::vector<std::string>& alternatives);
-
-private:
-  nux::GridHLayout*        _layout;
-  std::vector<std::string> _browser_alternatives;
-  std::vector<std::string> _photo_alternatives;
-  std::vector<std::string> _email_alternatives;
-  std::vector<std::string> _music_alternatives;
-
-  guint _ubus_handle;
-};
-
-}
-#endif
 
=== modified file 'plugins/unityshell/src/ResultViewGrid.cpp'
--- plugins/unityshell/src/ResultViewGrid.cpp	2012-01-02 21:39:28 +0000
+++ plugins/unityshell/src/ResultViewGrid.cpp	2012-01-26 08:37:26 +0000
@@ -626,8 +626,19 @@
         int half_width = recorded_dash_width_ / 2;
         int half_height = recorded_dash_height_;
 
-        int offset_x = MAX(MIN((x_position - half_width) / (half_width / 10), 5), -5);
-        int offset_y = MAX(MIN(((y_position + absolute_y) - half_height) / (half_height / 10), 5), -5);
+        int offset_x, offset_y;
+
+        /* Guard against divide-by-zero. SIGFPEs are not mythological
+         * contrary to popular belief */
+        if (half_width >= 10)
+          offset_x = MAX(MIN((x_position - half_width) / (half_width / 10), 5), -5);
+        else
+          offset_x = 0;
+
+        if (half_height >= 10)
+          offset_y = MAX(MIN(((y_position + absolute_y) - half_height) / (half_height / 10), 5), -5);
+        else
+          offset_y = 0;
 
         if (recorded_dash_width_ < 1 || recorded_dash_height_ < 1)
         {
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2012-01-16 16:03:32 +0000
+++ po/POTFILES.in	2012-01-26 08:37:26 +0000
@@ -3,7 +3,6 @@
 plugins/unityshell/src/LauncherController.cpp
 plugins/unityshell/src/PanelMenuView.cpp
 plugins/unityshell/src/PlacesGroup.cpp
-plugins/unityshell/src/PlacesHomeView.cpp
 plugins/unityshell/src/SpacerLauncherIcon.cpp
 plugins/unityshell/src/TrashLauncherIcon.cpp
 plugins/unityshell/src/BFBLauncherIcon.cpp
 
=== added file 'po/unity.pot'
--- po/unity.pot	1970-01-01 00:00:00 +0000
+++ po/unity.pot	2012-01-26 08:37:26 +0000
@@ -0,0 +1,120 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR Canonical\ Ltd
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: [e-mail]\n"
+"POT-Creation-Date: 2011-08-23 20:58-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <[e-mail]>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=CHARSET\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+msgid "Keep in launcher"
+msgstr ""
+
+msgid "Quit"
+msgstr ""
+
+msgid "Open"
+msgstr ""
+
+msgid "Eject"
+msgstr ""
+
+msgid "Eject parent drive"
+msgstr ""
+
+msgid "Safely remove"
+msgstr ""
+
+msgid "Safely remove parent drive"
+msgstr ""
+
+msgid "Unmount"
+msgstr ""
+
+msgid "The drive has been successfully ejected"
+msgstr ""
+
+msgid "Workspace Switcher"
+msgstr ""
+
+msgid "Search"
+msgstr ""
+
+msgid "Search across all places"
+msgstr ""
+
+msgid "See fewer results"
+msgstr ""
+
+msgid "Shortcuts"
+msgstr ""
+
+#. Media Apps
+msgid "Media Apps"
+msgstr ""
+
+#. Internet Apps
+msgid "Internet Apps"
+msgstr ""
+
+#. More Apps
+msgid "More Apps"
+msgstr ""
+
+#. Find Files
+msgid "Find Files"
+msgstr ""
+
+msgid "Browse the Web"
+msgstr ""
+
+#. Photos
+#. FIXME: Need to figure out the default
+msgid "View Photos"
+msgstr ""
+
+msgid "Check Email"
+msgstr ""
+
+msgid "Listen to Music"
+msgstr ""
+
+msgid "Drop To Add Application"
+msgstr ""
+
+msgid "Trash"
+msgstr ""
+
+msgid "Empty Trash..."
+msgstr ""
+
+msgid "Empty all items from Trash?"
+msgstr ""
+
+msgid "All items in the Trash will be permanently deleted."
+msgstr ""
+
+msgid "Empty Trash"
+msgstr ""
+
+msgid "Launcher & Menus"
+msgstr ""
+
+msgid "<b>Show the launcher when the pointer:</b>"
+msgstr ""
+
+msgid "Pushes the left edge of the screen"
+msgstr ""
+
+msgid "Touches the top left corner of the screen"
+msgstr ""
 
=== removed file 'po/unity.pot'
--- po/unity.pot	2012-01-15 14:03:49 +0000
+++ po/unity.pot	1970-01-01 00:00:00 +0000
@@ -1,120 +0,0 @@
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR Canonical\ Ltd
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"Report-Msgid-Bugs-To: [e-mail]\n"
-"POT-Creation-Date: 2011-08-23 20:58-0400\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <[e-mail]>\n"
-"Language: \n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=CHARSET\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-msgid "Keep in launcher"
-msgstr ""
-
-msgid "Quit"
-msgstr ""
-
-msgid "Open"
-msgstr ""
-
-msgid "Eject"
-msgstr ""
-
-msgid "Eject parent drive"
-msgstr ""
-
-msgid "Safely remove"
-msgstr ""
-
-msgid "Safely remove parent drive"
-msgstr ""
-
-msgid "Unmount"
-msgstr ""
-
-msgid "The drive has been successfully ejected"
-msgstr ""
-
-msgid "Workspace Switcher"
-msgstr ""
-
-msgid "Search"
-msgstr ""
-
-msgid "Search across all places"
-msgstr ""
-
-msgid "See fewer results"
-msgstr ""
-
-msgid "Shortcuts"
-msgstr ""
-
-#. Media Apps
-msgid "Media Apps"
-msgstr ""
-
-#. Internet Apps
-msgid "Internet Apps"
-msgstr ""
-
-#. More Apps
-msgid "More Apps"
-msgstr ""
-
-#. Find Files
-msgid "Find Files"
-msgstr ""
-
-msgid "Browse the Web"
-msgstr ""
-
-#. Photos
-#. FIXME: Need to figure out the default
-msgid "View Photos"
-msgstr ""
-
-msgid "Check Email"
-msgstr ""
-
-msgid "Listen to Music"
-msgstr ""
-
-msgid "Drop To Add Application"
-msgstr ""
-
-msgid "Trash"
-msgstr ""
-
-msgid "Empty Trash..."
-msgstr ""
-
-msgid "Empty all items from Trash?"
-msgstr ""
-
-msgid "All items in the Trash will be permanently deleted."
-msgstr ""
-
-msgid "Empty Trash"
-msgstr ""
-
-msgid "Launcher & Menus"
-msgstr ""
-
-msgid "<b>Show the launcher when the pointer:</b>"
-msgstr ""
-
-msgid "Pushes the left edge of the screen"
-msgstr ""
-
-msgid "Touches the top left corner of the screen"
-msgstr ""
 
=== modified file 'standalone-clients/CMakeLists.txt'
--- standalone-clients/CMakeLists.txt	2012-01-17 11:30:30 +0000
+++ standalone-clients/CMakeLists.txt	2012-01-26 08:37:26 +0000
@@ -76,8 +76,6 @@
                 ${UNITY_SRC}/FontSettings.h
                 ${UNITY_SRC}/IMTextEntry.cpp
                 ${UNITY_SRC}/IMTextEntry.h
-                ${UNITY_SRC}/PlacesHomeView.cpp
-                ${UNITY_SRC}/PlacesHomeView.h
                 ${UNITY_SRC}/PlacesGroup.cpp
                 ${UNITY_SRC}/PlacesGroup.h
                 ${UNITY_SRC}/PlacesTile.cpp
@@ -86,8 +84,6 @@
                 ${UNITY_SRC}/PlacesSimpleTile.h
                 ${UNITY_SRC}/PlacesVScrollBar.cpp
                 ${UNITY_SRC}/PlacesVScrollBar.h
-                ${UNITY_SRC}/HomeView.cpp
-                ${UNITY_SRC}/HomeView.h
                 ${UNITY_SRC}/DashStyle.cpp
                 ${UNITY_SRC}/IconLoader.cpp
                 ${UNITY_SRC}/IconLoader.h
 
=== modified file 'standalone-clients/standalone_dash.cpp'
--- standalone-clients/standalone_dash.cpp	2012-01-15 22:14:35 +0000
+++ standalone-clients/standalone_dash.cpp	2012-01-26 08:37:26 +0000
@@ -77,18 +77,8 @@
   self->Init ();
 }
 
-void
-ControlThread (nux::NThread* thread,
-               void*         data)
-{
-  // sleep for 3 seconds
-  nux::SleepForMilliseconds (3000);
-  printf ("ControlThread successfully started\n");
-}
-
 int main(int argc, char **argv)
 {
-  nux::SystemThread* st = NULL;
   nux::WindowThread* wt = NULL;
 
   gtk_init (&argc, &argv);
@@ -109,13 +99,7 @@
                             &TestRunner::InitWindowThread,
                             test_runner);
 
-  st = nux::CreateSystemThread (NULL, ControlThread, wt);
-
-  if (st)
-    st->Start (NULL);
-
   wt->Run (NULL);
-  delete st;
   delete wt;
   return 0;
 }
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-01-25 17:26:09 +0000
+++ tests/CMakeLists.txt	2012-01-26 08:37:26 +0000
@@ -119,11 +119,12 @@
                  test_glib_variant.cpp
                  ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
                  test_favorite_store_gsettings.cpp
+                 test_home_lens.cpp
                  test_shortcut_model.cpp
                  test_shortcut_private.cpp
                  test_introspection.cpp
                  test_main_xless.cpp
-		 test_grabhandle.cpp
+                 test_grabhandle.cpp
                  ${UNITY_SRC}/AbstractLauncherIcon.h
                  ${UNITY_SRC}/AbstractShortcutHint.h
                  ${UNITY_SRC}/Animator.cpp
@@ -152,11 +153,11 @@
                  ${UNITY_SRC}/Timer.h
                  ${UNITY_SRC}/WindowManager.cpp
                  ${UNITY_SRC}/WindowManager.h
-		 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle.cpp
-		 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-group.cpp
-		 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-impl-factory.cpp
-		 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-layout.cpp
-		 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-texture.cpp
+                 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle.cpp
+                 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-group.cpp
+                 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-impl-factory.cpp
+                 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-layout.cpp
+                 ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-texture.cpp
                  )
   target_link_libraries(test-gtest-xless ${GTEST_BOTH_LIBRARIES} ${GMOCK_LIB} ${GMOCK_MAIN_LIB})
   add_test(UnityGTestXless test-gtest-xless)
 
=== added file 'tests/test_home_lens.cpp'
--- tests/test_home_lens.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_home_lens.cpp	2012-01-26 08:37:26 +0000
@@ -0,0 +1,362 @@
+#include <gtest/gtest.h>
+#include <glib-object.h>
+#include <dee.h>
+#include <string>
+#include <iostream>
+#include <stdexcept>
+#include <map>
+#include <memory>
+#include <sigc++/signal.h>
+#include <sigc++/trackable.h>
+
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Variant.h>
+#include <UnityCore/HomeLens.h>
+#include <UnityCore/Lens.h>
+#include <UnityCore/Lenses.h>
+
+#include "test_utils.h"
+
+using namespace std;
+using namespace unity::dash;
+
+namespace
+{
+
+/*
+ * FORWARDS
+ */
+
+class StaticTestLens;
+
+typedef struct {
+  StaticTestLens* lens;
+  gchar*          search_string;
+} LensSearchClosure;
+
+static gboolean dispatch_global_search(gpointer userdata);
+
+
+/*
+ * Mock Lens instance that does not use DBus. The default search does like this:
+ * For input "bar" output:
+ *
+ * i = 0
+ * for letter in "bar":
+ *   put result row [ "uri+$letter+$lens_id", "icon+$letter+$lens_id", i % 3, "mime+$letter+$lens_id", ...]
+ *   i++
+ *
+ * The mock lens has 3 categories:
+ *
+ *  0) "cat0+$lens_id"
+ *  1) "cat1+$lens_id"
+ *  2) "Shared cat"
+ */
+class StaticTestLens : public Lens
+{
+public:
+  typedef std::shared_ptr<StaticTestLens> Ptr;
+
+  StaticTestLens(string const& id, string const& name, string const& description, string const& search_hint)
+    : Lens(id, "", "", name, "lens-icon.png",
+           description, search_hint, true, "",
+           ModelType::LOCAL)
+  {
+    search_in_global(true);
+
+    DeeModel* cats = categories()->model();
+    DeeModel* results = global_results()->model();
+    DeeModel* flters = filters()->model();
+
+    // Set model schemas
+    dee_model_set_schema(cats, "s", "s", "s", "a{sv}", NULL);
+    dee_model_set_schema(results, "s", "s", "u", "s", "s", "s", "s", NULL);
+    dee_model_set_schema(flters, "s", "s", "s", "s", "a{sv}", "b", "b", "b", NULL);
+
+    // Populate categories model
+    ostringstream cat0, cat1;
+    cat0 << "cat0+" << id;
+    cat1 << "cat1+" << id;
+    GVariantBuilder b;
+    g_variant_builder_init(&b, G_VARIANT_TYPE_VARDICT);
+    GVariant *asv = g_variant_builder_end(&b);
+
+    dee_model_append(cats, cat0.str().c_str(), "icon.png", "tile-vertical", asv);
+    dee_model_append(cats, cat1.str().c_str(), "icon.png", "tile-vertical", asv);
+    dee_model_append(cats, "Shared cat", "icon.png", "tile-vertical", asv);
+  }
+
+  virtual ~StaticTestLens() {}
+
+  virtual void DoGlobalSearch(string const& search_string)
+  {
+    DeeModel* model = global_results()->model();
+    GVariant** row_buf = g_new(GVariant*, 8);
+
+    row_buf[1] = g_variant_new_string("");
+    row_buf[3] = g_variant_new_string("");
+    row_buf[4] = g_variant_new_string("");
+    row_buf[5] = g_variant_new_string("");
+    row_buf[6] = g_variant_new_string("");
+    row_buf[7] = NULL;
+
+    unsigned int i;
+    for (i = 0; i < search_string.size(); i++)
+    {
+      ostringstream uri;
+      uri << "uri+" << search_string.at(i) << "+" << id();
+      row_buf[0] = g_variant_new_string(uri.str().c_str());
+      row_buf[2] = g_variant_new_uint32(i % 3);
+
+      dee_model_append_row(model, row_buf);
+    }
+
+    g_free(row_buf);
+  }
+
+  void GlobalSearch(string const& search_string)
+  {
+    /* Dispatch search async, because that's */
+    LensSearchClosure* closure = g_new0(LensSearchClosure, 1);
+    closure->lens = this;
+    closure->search_string = g_strdup(search_string.c_str());
+    g_idle_add(dispatch_global_search, closure);
+  }
+
+  void Search(string const& search_string)
+  {
+
+  }
+
+  void Activate(string const& uri)
+  {
+
+  }
+
+  void Preview(string const& uri)
+  {
+
+  }
+
+};
+
+static gboolean dispatch_global_search(gpointer userdata)
+{
+  LensSearchClosure* closure = (LensSearchClosure*) userdata;
+
+  closure->lens->DoGlobalSearch(closure->search_string);
+
+  g_free(closure->search_string);
+  g_free(closure);
+
+  return FALSE;
+}
+
+/*
+ * Mock Lenses class
+ */
+class StaticTestLenses : public Lenses
+{
+public:
+  typedef std::shared_ptr<StaticTestLenses> Ptr;
+
+  StaticTestLenses()
+  {
+    count.SetGetterFunction(sigc::mem_fun(&list_, &Lenses::LensList::size));
+  }
+
+  virtual ~StaticTestLenses() {}
+
+  Lenses::LensList GetLenses() const
+  {
+    return list_;
+  }
+
+  Lens::Ptr GetLens(std::string const& lens_id) const
+  {
+    for (auto lens : list_)
+    {
+      if (lens->id() == lens_id)
+        return lens;
+    }
+    return Lens::Ptr();
+  }
+
+  Lens::Ptr GetLensAtIndex(std::size_t index) const
+  {
+    return list_.at(index);
+  }
+
+protected:
+  Lenses::LensList list_;
+};
+
+class TwoStaticTestLenses : public StaticTestLenses
+{
+public:
+  TwoStaticTestLenses()
+  : lens_1_(new StaticTestLens("first.lens", "First Lens", "The very first lens", "First search hint"))
+  , lens_2_(new StaticTestLens("second.lens", "Second Lens", "The second lens", "Second search hint"))
+  {
+    list_.push_back(lens_1_);
+    list_.push_back(lens_2_);
+  }
+
+private:
+  Lens::Ptr lens_1_;
+  Lens::Ptr lens_2_;
+};
+
+TEST(TestHomeLens, TestConstruction)
+{
+  HomeLens home_lens_("name", "description", "searchhint");
+
+  EXPECT_EQ(home_lens_.id(), "home.lens");
+  EXPECT_EQ(home_lens_.connected, false);
+  EXPECT_EQ(home_lens_.search_in_global, false);
+  EXPECT_EQ(home_lens_.name, "name");
+  EXPECT_EQ(home_lens_.description, "description");
+  EXPECT_EQ(home_lens_.search_hint, "searchhint");
+}
+
+TEST(TestHomeLens, TestInitiallyEmpty)
+{
+  HomeLens home_lens_("name", "description", "searchhint");
+  DeeModel* results = home_lens_.results()->model();
+  DeeModel* categories = home_lens_.categories()->model();;
+  DeeModel* filters = home_lens_.filters()->model();;
+
+  EXPECT_EQ(dee_model_get_n_rows(results), 0);
+  EXPECT_EQ(dee_model_get_n_rows(categories), 0);
+  EXPECT_EQ(dee_model_get_n_rows(filters), 0);
+
+  EXPECT_EQ(home_lens_.count(), 0);
+}
+
+TEST(TestHomeLens, TestTwoStaticLenses)
+{
+  HomeLens home_lens_("name", "description", "searchhint");
+  TwoStaticTestLenses lenses_;
+
+  home_lens_.AddLenses(lenses_);
+
+  EXPECT_EQ(home_lens_.count, (size_t) 2);
+
+  /* Test iteration of registered lensess */
+  map<string,string> remaining;
+  remaining["first.lens"] = "";
+  remaining["second.lens"] = "";
+  for (auto lens : home_lens_.GetLenses())
+  {
+    remaining.erase(lens->id());
+  }
+
+  EXPECT_EQ(remaining.size(), 0);
+
+  /* Test sorting and GetAtIndex */
+  EXPECT_EQ(home_lens_.GetLensAtIndex(0)->id(), "first.lens");
+  EXPECT_EQ(home_lens_.GetLensAtIndex(1)->id(), "second.lens");
+}
+
+TEST(TestHomeLens, TestCategoryMerging)
+{
+  HomeLens home_lens_("name", "description", "searchhint");
+  TwoStaticTestLenses lenses_;
+  DeeModel* cats = home_lens_.categories()->model();
+  DeeModelIter* iter;
+  unsigned int cat0_first = 0,
+                cat1_first = 1,
+                cat_shared = 2,
+                cat0_second = 3,
+                cat1_second = 4;
+  const unsigned int NAME_COLUMN = 0;
+
+  home_lens_.AddLenses(lenses_);
+
+  EXPECT_EQ(dee_model_get_n_rows(cats), 5); // 5 because each lens has 3 cats, but 1 is shared between them
+
+  /* Validate the merged categories */
+  iter = dee_model_get_iter_at_row(cats, cat0_first);
+  EXPECT_EQ("cat0+first.lens", string(dee_model_get_string(cats, iter, NAME_COLUMN)));
+
+  iter = dee_model_get_iter_at_row(cats, cat1_first);
+  EXPECT_EQ("cat1+first.lens", string(dee_model_get_string(cats, iter, NAME_COLUMN)));
+
+  iter = dee_model_get_iter_at_row(cats, cat_shared);
+  EXPECT_EQ("Shared cat", string(dee_model_get_string(cats, iter, NAME_COLUMN)));
+
+  iter = dee_model_get_iter_at_row(cats, cat0_second);
+  EXPECT_EQ("cat0+second.lens", string(dee_model_get_string(cats, iter, NAME_COLUMN)));
+
+  iter = dee_model_get_iter_at_row(cats, cat1_second);
+  EXPECT_EQ("cat1+second.lens", string(dee_model_get_string(cats, iter, NAME_COLUMN)));
+}
+
+// It's not that we must not support filters. It is just not implemented yet.
+// But we actively test against it to make sure we don't end up with broken
+// filters in the UI. When/if we land support for filters on the home screen
+// this test should obviously be removed
+TEST(TestHomeLens, TestIgnoreFilters)
+{
+  HomeLens home_lens_("name", "description", "searchhint");
+  TwoStaticTestLenses lenses_;
+  DeeModel* filters = home_lens_.filters()->model();
+
+  EXPECT_EQ(dee_model_get_n_rows(filters), 0);
+}
+
+TEST(TestHomeLens, TestOneSearch)
+{
+  HomeLens home_lens_("name", "description", "searchhint");
+  TwoStaticTestLenses lenses_;
+  DeeModel* results = home_lens_.results()->model();
+  DeeModel* cats = home_lens_.categories()->model();
+  DeeModel* filters = home_lens_.filters()->model();
+  DeeModelIter* iter;
+  unsigned int cat0_first = 0,
+                cat1_first = 1,
+                cat_shared = 2,
+                cat0_second = 3,
+                cat1_second = 4;
+  const unsigned int URI_COLUMN = 0;
+  const unsigned int CAT_COLUMN = 2;
+
+  home_lens_.AddLenses(lenses_);
+
+  home_lens_.Search("ape");
+
+  Utils::WaitForTimeoutMSec();
+
+  /* Validate counts */
+  EXPECT_EQ(dee_model_get_n_rows(results), 6); // 3 hits from each lens
+  EXPECT_EQ(dee_model_get_n_rows(cats), 5); // 5 because each lens has 3 cats, but 1 is shared between them
+  EXPECT_EQ(dee_model_get_n_rows(filters), 0); // We ignore filters deliberately currently
+
+  /* Validate results. In particular that we get the correct merged
+   * category offsets assigned */
+  iter = dee_model_get_iter_at_row(results, 0);
+  EXPECT_EQ(string("uri+a+first.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ(cat0_first, dee_model_get_uint32(results, iter, CAT_COLUMN));
+
+  iter = dee_model_get_iter_at_row(results, 1);
+  EXPECT_EQ(string("uri+p+first.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ(cat1_first, dee_model_get_uint32(results, iter, CAT_COLUMN));
+
+  iter = dee_model_get_iter_at_row(results, 2);
+  EXPECT_EQ(string("uri+e+first.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ(cat_shared, dee_model_get_uint32(results, iter, CAT_COLUMN));
+
+  iter = dee_model_get_iter_at_row(results, 3);
+  EXPECT_EQ(string("uri+a+second.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ(cat0_second, dee_model_get_uint32(results, iter, CAT_COLUMN));
+
+  iter = dee_model_get_iter_at_row(results, 4);
+  EXPECT_EQ(string("uri+p+second.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ(cat1_second, dee_model_get_uint32(results, iter, CAT_COLUMN));
+
+  iter = dee_model_get_iter_at_row(results, 5);
+  EXPECT_EQ(string("uri+e+second.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ(cat_shared, dee_model_get_uint32(results, iter, CAT_COLUMN));
+}
+
+}
 
=== modified file 'tests/test_utils.h'
--- tests/test_utils.h	2011-12-02 12:03:27 +0000
+++ tests/test_utils.h	2012-01-26 08:37:26 +0000
@@ -51,6 +51,33 @@
     return g_timeout_add_seconds(timeout_duration, TimeoutCallback, timeout_reached);
   }
 
+  static guint32 ScheduleTimeoutMSec(bool* timeout_reached, unsigned int timeout_duration = 10)
+  {
+    return g_timeout_add(timeout_duration, TimeoutCallback, timeout_reached);
+  }
+
+  static void WaitForTimeout(unsigned int timeout_duration = 10)
+  {
+    bool timeout_reached = false;
+    guint32 timeout_id = ScheduleTimeout(&timeout_reached, timeout_duration);
+
+    while (!timeout_reached)
+      g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+    g_source_remove(timeout_id);
+  }
+
+  static void WaitForTimeoutMSec(unsigned int timeout_duration = 10)
+    {
+      bool timeout_reached = false;
+      guint32 timeout_id = ScheduleTimeoutMSec(&timeout_reached, timeout_duration);
+
+      while (!timeout_reached)
+        g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+      g_source_remove(timeout_id);
+    }
+
 private:
   static gboolean TimeoutCallback(gpointer data)
   {