Merge lp:~gordallott/unity/hud into lp:unity

[Gord Allott]

[Michal Hruby (mhr3)]

50 - self->owner_->connected.emit();

Why is this needed?

review: Needs Information

[Marco Biscaro (marcobiscaro2112)]

- lens_ = service_lens_new();
- model_ = service_model_new();
+ //lens_ = service_lens_new();
+ //model_ = service_model_new();
+ hud_ = service_hud_new();

If this lines are no longer necessary, they can be removed instead of commented.

- g_object_unref(lens_);
- g_object_unref(model_);
+ //g_object_unref(lens_);
+ //g_object_unref(model_);
+ g_object_unref(hud_);

The same thing here.

[Marco Biscaro (marcobiscaro2112)]

review: Needs Fixing

[Thomi Richards (thomir-deactivatedaccount)]

Hi,

There are a few introspection / autopilot issues with this branch:

Your HUDController derives from Introspectable, but you never use it. You need to:
 1) Add it to the introspection tree.At Diff line 2729 (where you create the HUDController instance) you need to call "AddChild(hud_controller_.get());". If the HUDController is ever deleted, you need to call "RemoveChild(hud_controller_.get());" BEFFORE the deletion takes place.

 2) Add properties to the HUD controller that will be useful in autopilot tests.

You need to repeat this process with all child objects of the HUDController that derive from Introspectable.

Finally, the string returned from "GetName" should be "HUDController" - you don't need to qualify it with "unity.hud".

In HUDIcon.h you #include "Introspectable.h", but never use it.

In HUDView.h, you've declared a "const gchar* GetName()" method, which is from Introspectable, but there's two problems:
 1) You don't derive from Introsopectable (as noted above, you should).
 2) That's not the correct method signiture - the return type is "std::string", and the method is const.

In the same class, make sure you add the search bar to the introspection tree - that way we can get the current search string.

Finally, it'd be really nice to have some autopilot tests written when this is merged. I don't mind helping you with this.

Cheers,

review: Needs Fixing

[Gord Allott (gordallott)]

> Hi,
>
> There are a few introspection / autopilot issues with this branch:
>
> Your HUDController derives from Introspectable, but you never use it. You need
> to:
> 1) Add it to the introspection tree.At Diff line 2729 (where you create the
> HUDController instance) you need to call "AddChild(hud_controller_.get());".
> If the HUDController is ever deleted, you need to call
> "RemoveChild(hud_controller_.get());" BEFFORE the deletion takes place.
>
> 2) Add properties to the HUD controller that will be useful in autopilot
> tests.
>
>
> You need to repeat this process with all child objects of the HUDController
> that derive from Introspectable.
>
> Finally, the string returned from "GetName" should be "HUDController" - you
> don't need to qualify it with "unity.hud".
>
> In HUDIcon.h you #include "Introspectable.h", but never use it.
>
> In HUDView.h, you've declared a "const gchar* GetName()" method, which is from
> Introspectable, but there's two problems:
> 1) You don't derive from Introsopectable (as noted above, you should).
> 2) That's not the correct method signiture - the return type is
> "std::string", and the method is const.
>
> In the same class, make sure you add the search bar to the introspection tree
> - that way we can get the current search string.
>

Very much so, Introspection was on my todo list for earlier in the week before last minute changes bumped it off, will fix that up

> Finally, it'd be really nice to have some autopilot tests written when this is
> merged. I don't mind helping you with this.
>

Already have a guy from Systems helping out there, for now manual but he's going through and converting them :)

> Cheers,

[Gord Allott (gordallott)]

> - lens_ = service_lens_new();
> - model_ = service_model_new();
> + //lens_ = service_lens_new();
> + //model_ = service_model_new();
> + hud_ = service_hud_new();
>
> If this lines are no longer necessary, they can be removed instead of
> commented.
>
> - g_object_unref(lens_);
> - g_object_unref(model_);
> + //g_object_unref(lens_);
> + //g_object_unref(model_);
> + g_object_unref(hud_);
>
> The same thing here.

Actually was just left over debugging code ;)

[Michal Hruby (mhr3)]

49 self->connected_ = true;
50 - self->owner_->connected.emit();

So can we at least not fool IsConnected() users (ie remove the "self->connected_ = true;" as well pls)

150 + GVariant* query_key = g_variant_get_child_value(query, 2);

Please check that the variant has at least 2 children (or at least that query_key != NULL)

153 + GVariant* queries = g_variant_get_child_value(query, 1);
173, 176, 189, 192

Same

[Mirco Müller (macslow)]

Getting this error during compilation atm:

CMakeFiles/test-gtest-dbus.dir/test_hud.cpp.o: In function `TestBody':
/tmp/fasel/unity/tests/test_hud.cpp:30: undefined reference to `unity::hud::Hud::Hud(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'
/tmp/fasel/unity/tests/test_hud.cpp:93: undefined reference to `unity::hud::Hud::RequestQuery(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'
/tmp/fasel/unity/tests/test_hud.cpp:100: undefined reference to `unity::hud::Hud::CloseQuery()'
collect2: ld returned 1 exit status
make[2]: *** [tests/test-gtest-dbus] Error 1
make[1]: *** [tests/CMakeFiles/test-gtest-dbus.dir/all] Error 2
make: *** [all] Error 2

review: Needs Fixing

[Mirco Müller (macslow)]

Above mentioned issue solved... typical cmake picking up the wrong libunity-core.so *sigh³*

[Mirco Müller (macslow)]

Is the HUD really meant to use the exact same button-visuals from the dash? Does Design demand that?

Should the HUD-searchbar not be of the same width as the Dash-searchbar (in non-fullscreen state at least)?

Please get into the habbit of using const int/float in an unnamed namespace instead of "magic" numbers for padding/margins/sizes... you don't use that consistently across this branch... check:

...
+ layout_->AddLayout(new nux::SpaceLayout(8,8,8,8), 0);
...
+ icon_layout->SetVerticalExternalMargin(12);
...
+ search_bar_ = new unity::SearchBar(940, true);
...
+ button_views_->SetHorizontalExternalMargin(12);
+ button_views_->SetMaximumWidth(940);
...
+ hud_controller_->launcher_width = optionGetIconSize() + 18;

review: Needs Fixing

[Andrea Azzarone (azzar1)]

997 + nux::Geometry content_geo = view_->GetGeometry();
998 + nux::Geometry geo = GetIdealWindowGeometry();

If is it possible, please do something like this:

997 + nux::Geometry const& content_geo = view_->GetGeometry();
998 + nux::Geometry geo(GetIdealWindowGeometry());

or at least:
997 + nux::Geometry content_geo(view_->GetGeometry());
998 + nux::Geometry geo(GetIdealWindowGeometry());

[Andrea Azzarone (azzar1)]

review: Needs Fixing

[John Lea (johnlea)]

A great improvement, still a bunch of outstanding changes required but a good step in the right direction. Branch approved, look forward to seeing the next iteration with further finesse.

review: Approve (design review)

[Gord Allott (gordallott)]

approving as latest revision just fixed up conflicts

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-02-03 15:02:15 +0000
+++ CMakeLists.txt	2012-02-06 11:00:29 +0000
@@ -113,7 +113,7 @@
     SET (BOOT_LOGGER_FLAG "-DENABLE_LOGGER")
 endif (BOOT_LOGGER)
 
-SET (MAINTAINER_CFLAGS "-Werror -Wall -Wcast-align -Wno-uninitialized -Wempty-body -Wformat-security -Winit-self -Warray-bounds")
+SET (MAINTAINER_CFLAGS "-Wall -Wcast-align -Wno-uninitialized -Wempty-body -Wformat-security -Winit-self -Warray-bounds")
 option (DISABLE_MAINTAINER_CFLAGS "Disable maintainer CFlags" OFF)
 if (DISABLE_MAINTAINER_CFLAGS)
   SET (MAINTAINER_CFLAGS "")

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2012-01-18 13:32:26 +0000
+++ UnityCore/CMakeLists.txt	2012-02-06 11:00:29 +0000
@@ -21,6 +21,7 @@
      GLibSignal-inl.h
      GLibWrapper.h
      GLibWrapper-inl.h
+     Hud.h
      HomeLens.h
      IndicatorEntry.h
      Indicator.h
@@ -54,6 +55,7 @@
      GLibDBusProxy.cpp
      GLibSignal.cpp
      GLibWrapper.cpp
+     Hud.cpp
      HomeLens.cpp
      Indicator.cpp
      IndicatorEntry.cpp

=== modified file 'UnityCore/GLibDBusProxy.cpp'
--- UnityCore/GLibDBusProxy.cpp	2012-01-19 11:01:58 +0000
+++ UnityCore/GLibDBusProxy.cpp	2012-02-06 11:00:29 +0000
@@ -141,11 +141,7 @@
                                      gpointer impl)
 {
   DBusProxy::Impl* self = static_cast<DBusProxy::Impl*>(impl);
-
   LOG_DEBUG(logger) << self->name_ << " appeared";
-
-  self->connected_ = true;
-  self->owner_->connected.emit();
 }
 
 void DBusProxy::Impl::OnNameVanished(GDBusConnection* connection,

=== added file 'UnityCore/Hud.cpp'
--- UnityCore/Hud.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/Hud.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,255 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ */
+// 
+#include "Hud.h"
+
+#include <gio/gio.h>
+#include <glib.h>
+#include <NuxCore/Logger.h>
+#include "GLibWrapper.h"
+#include "GLibDBusProxy.h"
+
+#include "config.h"
+
+#include <sigc++/bind.h>
+
+namespace unity
+{
+namespace hud
+{
+
+namespace
+{
+nux::logging::Logger logger("unity.hud.hud");
+const int request_number_of_results = 6;
+}
+
+// Impl classes
+class HudImpl
+{
+public:
+  HudImpl(std::string const& dbus_name,
+          std::string const& dbus_path,
+          Hud *parent)
+  : query_key_(NULL)
+  , proxy_(dbus_name, dbus_path, "com.canonical.hud")
+  , parent_(parent)
+  {
+    LOG_DEBUG(logger) << "Hud init with name: " << dbus_name << "and path: " << dbus_path;
+    proxy_.connected.connect([&]() { 
+      LOG_DEBUG(logger) << "Hud Connected"; 
+      parent_->connected = true; 
+    });
+
+    proxy_.Connect("UpdatedQuery", sigc::mem_fun(this, &HudImpl::UpdateQueryCallback));
+  }
+
+  void QueryCallback(GVariant* data);
+  void UpdateQueryCallback(GVariant* data);
+  void BuildQueries(GVariant* query_array);
+  void ExecuteByKey(GVariant* key, unsigned int timestamp);
+  void ExecuteQueryByStringCallback(GVariant* query, unsigned int timestamp);
+  void CloseQuery();
+
+  GVariant* query_key_;
+  Hud::Queries queries_;
+  glib::DBusProxy proxy_;
+  Hud* parent_;
+};
+
+void HudImpl::ExecuteByKey(GVariant* key, unsigned int timestamp)
+{
+  LOG_DEBUG(logger) << "Executing by Key";
+  
+  GVariantBuilder tuple;
+  g_variant_builder_init(&tuple, G_VARIANT_TYPE_TUPLE);
+  g_variant_builder_add_value(&tuple, g_variant_new_variant(key));
+  g_variant_builder_add_value(&tuple, g_variant_new_uint32(timestamp));
+  
+  proxy_.Call("ExecuteQuery", g_variant_builder_end(&tuple));
+}
+
+void HudImpl::ExecuteQueryByStringCallback(GVariant* query, unsigned int timestamp)
+{
+  if (g_variant_n_children(query) < 3)
+  {
+    LOG_ERROR(logger) << "Received (" << g_variant_n_children(query) << ") children in a query, expected 3";
+    return;
+  }
+  
+  queries_.clear();
+  
+  GVariant* query_key = g_variant_get_child_value(query, 2);
+  query_key_ = query_key; 
+ 
+  GVariant* queries = g_variant_get_child_value(query, 1);
+  BuildQueries(queries);
+  g_variant_unref(queries);
+  
+  if (queries_.empty() == false)
+  {
+    // we now execute based off the first result
+    ExecuteByKey(queries_.front()->key, timestamp);
+    CloseQuery();
+  }
+}
+
+void HudImpl::QueryCallback(GVariant* query)
+{
+  if (g_variant_n_children(query) < 3)
+  {
+    LOG_ERROR(logger) << "Received (" << g_variant_n_children(query) << ") children in a query, expected 3";
+    return;
+  }
+  queries_.clear();
+
+  // extract the information from the GVariants
+  GVariant* target = g_variant_get_child_value(query, 0);
+  g_variant_unref(target);
+  
+  GVariant* query_key = g_variant_get_child_value(query, 2);
+  query_key_ = query_key; 
+ 
+  GVariant* queries = g_variant_get_child_value(query, 1);
+  BuildQueries(queries);
+  g_variant_unref(queries);
+  
+  parent_->queries_updated.emit(queries_);
+}
+
+void HudImpl::UpdateQueryCallback(GVariant* query)
+{
+  if (g_variant_n_children(query) < 3)
+  {
+    LOG_ERROR(logger) << "Received (" << g_variant_n_children(query) << ") children in a query, expected 3";
+    return;
+  }
+  // as we are expecting an update, we want to check
+  // and make sure that we are the actual receivers of
+  // the signal
+
+  GVariant* query_key = g_variant_get_child_value(query, 2);
+  if (g_variant_equal(query_key_, query_key))
+  {
+    GVariant* queries = g_variant_get_child_value(query, 1);
+    BuildQueries(queries);
+    g_variant_unref(queries);
+  }
+}
+
+void HudImpl::BuildQueries(GVariant* query_array)
+{
+  GVariantIter iter;
+  g_variant_iter_init(&iter, query_array);
+  glib::String formatted_text;
+  glib::String icon;
+  glib::String item_icon;
+  glib::String completion_text;
+  glib::String shortcut;
+  GVariant* key = NULL;
+  
+  while (g_variant_iter_loop(&iter, "(sssssv)", 
+         &formatted_text, &icon, &item_icon, &completion_text, &shortcut, &key))
+  {
+    queries_.push_back(Query::Ptr(new Query(formatted_text, 
+                                            icon,
+                                            item_icon, 
+                                            completion_text,
+                                            shortcut,
+                                            key)));
+  }
+}
+
+void HudImpl::CloseQuery()
+{ 
+  if (query_key_ == NULL)
+  {
+    LOG_WARN(logger) << "Attempted to close the hud connection without starting it";
+  }
+  else
+  {
+    GVariant* paramaters = g_variant_new("(v)", query_key_);
+    proxy_.Call("CloseQuery", paramaters);
+    g_variant_unref(query_key_);
+    query_key_ = NULL;
+    queries_.clear();
+  }
+}
+
+
+Hud::Hud(std::string const& dbus_name,
+         std::string const& dbus_path)
+    : connected(false)
+    , pimpl_(new HudImpl(dbus_name, dbus_path, this))
+{
+  pimpl_->parent_ = this;
+}
+
+Hud::~Hud()
+{
+  delete pimpl_;
+}
+
+void Hud::RequestQuery(std::string const& search_string)
+{
+  LOG_DEBUG(logger) << "Getting Query: " << search_string;
+  if (pimpl_->query_key_ != NULL)
+  {
+    CloseQuery();
+  }
+
+  GVariant* paramaters = g_variant_new("(si)", 
+                                       search_string.c_str(), 
+                                       request_number_of_results);
+  pimpl_->proxy_.Call("StartQuery", paramaters, sigc::mem_fun(this->pimpl_, &HudImpl::QueryCallback));
+}
+
+
+void Hud::ExecuteQuery(Query::Ptr query, unsigned int timestamp)
+{
+  LOG_DEBUG(logger) << "Executing query: " << query->formatted_text;
+  pimpl_->ExecuteByKey(query->key, timestamp);
+}
+
+void Hud::ExecuteQueryBySearch(std::string execute_string, unsigned int timestamp)
+{
+  //Does a search then executes the result based on that search
+  LOG_DEBUG(logger) << "Executing by string" << execute_string;
+  if (pimpl_->query_key_ != NULL)
+  {
+    CloseQuery(); 
+  }
+
+  GVariant* paramaters = g_variant_new("(si)", 
+                                       execute_string.c_str(),
+                                       1);
+
+  auto functor = sigc::mem_fun(this->pimpl_, &HudImpl::ExecuteQueryByStringCallback);
+
+  pimpl_->proxy_.Call("StartQuery", paramaters, sigc::bind(functor, timestamp));
+}
+
+void Hud::CloseQuery()
+{
+  //Send close hint to the hud
+  pimpl_->CloseQuery();
+}
+
+}
+}

=== added file 'UnityCore/Hud.h'
--- UnityCore/Hud.h	1970-01-01 00:00:00 +0000
+++ UnityCore/Hud.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,127 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ */
+
+#ifndef UNITY_HUD_H
+#define UNITY_HUD_H
+
+#include <deque>
+#include <string>
+#include <memory>
+#include <NuxCore/Property.h>
+#include <glib/gvariant.h>
+
+namespace unity
+{
+namespace hud
+{
+
+
+class Query
+{
+public:
+  typedef std::shared_ptr<Query> Ptr;
+  
+  Query(std::string const& formatted_text_, std::string const& icon_name_,
+        std::string const& item_icon_, std::string const& completion_text_,
+        std::string const& shortcut_, GVariant* key_)
+  : formatted_text(formatted_text_)
+  , icon_name(icon_name_)
+  , item_icon(item_icon_)
+  , completion_text(completion_text_)
+  , shortcut(shortcut_)
+  , key(key_)
+  {
+    g_variant_ref(key);
+  }
+  
+  ~Query()
+  {
+    g_variant_unref(key);
+  }
+  
+  Query(const Query &rhs);
+  Query& operator=(Query);
+
+  std::string formatted_text;   // Pango formatted text
+  std::string icon_name;        // icon name using standard lookups
+  std::string item_icon;        // Future API
+  std::string completion_text;  // Non formatted text f or completion
+  std::string shortcut;         // Shortcut key
+  GVariant *key;
+};
+
+
+class HudImpl;
+class Hud
+{
+public:
+  typedef std::shared_ptr<Hud> Ptr;
+  typedef std::deque<Query::Ptr> Queries;
+
+  /*
+   * Constructor for the hud
+   * \param dbus_name string that specifies the name of the hud service
+   * \param dbus_path string that specifies the path of the hud service
+   */
+  Hud(std::string const& dbus_name,
+      std::string const& dbus_path);
+
+  ~Hud();
+
+  Hud(const Hud &rhs);
+  Hud& operator=(Hud);
+
+  nux::Property<std::string> target;
+  nux::Property<bool> connected;
+
+  /*
+   * Queries the service for new suggestions, will fire off the 
+   * suggestion_search_finished signal when the suggestions are returned
+   */
+  void RequestQuery(std::string const& search_string);
+  
+  /*
+   * Executes a Query
+   */
+  void ExecuteQuery(Query::Ptr query, unsigned int timestamp);
+
+  /*
+   * Executes a query that returns from a search,
+   * Implicitly calls CloseQuery();
+   */
+  void ExecuteQueryBySearch(std::string execute_string, unsigned int timestamp);
+
+  /*
+   * Closes the query connection, call when the hud closes
+   */
+  void CloseQuery();
+
+  /*
+   * Returns a deque of Query types when the service provides them
+   */
+  sigc::signal<void, Queries> queries_updated;
+
+private:
+  HudImpl *pimpl_;
+};
+
+}
+}
+
+#endif /* UNITY_HUD_H */

=== added file 'manual-tests/Hud.txt'
--- manual-tests/Hud.txt	1970-01-01 00:00:00 +0000
+++ manual-tests/Hud.txt	2012-02-06 11:00:29 +0000
@@ -0,0 +1,57 @@
+For reference, the term Tap means to press the indicated key and release it, within a timeframe of 50ms
+
+Hud Invocate
+-----------
+This test makes sure that the hud presents itself, the launcher hides 
+and the panel changes
+
+#. Tap Alt
+
+Outcome
+  The hud interface presents itself with no other interface such as the dash present.
+  The Launcher hides, the panel becomes transparent with a colour tint matching the hud
+
+Hud Search
+-----------
+This test makes sure that the hud will search and activate items.
+
+#. Ensure the devices indicator is present
+#. Tap Alt
+#. Type "system" to search for the "System settings..." item in the devices indicator
+#. Press return to activate the search query. 
+
+Outcome
+  The system settings interface presents itself, the hud disappears. 
+  If the hud does not disappear, this test failed. If the system settings interface
+  did not present itself, this test did *not* fail. 
+
+
+Hud Key-Navigation
+-----------
+This test ensures the hud key navigation is intact
+
+#. Ensure the messaging indicator is present
+#. Tap Alt
+#. Type "Message" to search for items from the messaging indicator
+#. Press down twice
+#. Press return
+
+Outcome
+  The item selected will activate and the hud with disappear.
+  If the hud does not disappear, this test failed.
+  If the buttons under the search box do not highlight, this test failed.
+
+
+Hud Dismiss
+----------
+This test ensures that the hud is dismissable
+
+#. Tap Alt
+#. Type "test"
+#. Press escape
+#. Click anywhere on the screen that is not the hud interface
+
+Outcome
+  After pressing escape in step three, the text "test" should be removed from the hud search
+  After step four, the hud should dismiss itself and not be present.
+

=== modified file 'plugins/unityshell/src/DashController.cpp'
--- plugins/unityshell/src/DashController.cpp	2012-02-04 01:55:49 +0000
+++ plugins/unityshell/src/DashController.cpp	2012-02-06 11:00:29 +0000
@@ -118,6 +118,18 @@
                                  sigc::mem_fun(this, &Controller::OnActivateRequest));
   ubus_manager_.RegisterInterest(UBUS_DASH_ABOUT_TO_SHOW,
                                  [&] (GVariant*) { EnsureDash(); });
+  ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, [&] (GVariant *data) {
+    unity::glib::String overlay_identity;
+    gboolean can_maximise = FALSE;
+    gint32 overlay_monitor = 0;
+    g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING, &overlay_identity, &can_maximise, &overlay_monitor);
+    
+    // hide if something else is coming up
+    if (g_strcmp0(overlay_identity, "dash"))
+    {
+      HideDash(true);
+    }
+  }); 
 }
 
 void Controller::EnsureDash()

=== modified file 'plugins/unityshell/src/DashStyle.cpp'
--- plugins/unityshell/src/DashStyle.cpp	2012-01-19 11:57:37 +0000
+++ plugins/unityshell/src/DashStyle.cpp	2012-02-06 11:00:29 +0000
@@ -119,6 +119,7 @@
   void Text(cairo_t* cr,
             nux::Color const& color,
             std::string const& label,
+            int font_size = -1,
             double horizMargin = 10.0,
             Alignment alignment = Alignment::CENTER);
 
@@ -1325,6 +1326,7 @@
 void Style::Impl::Text(cairo_t*    cr,
                        nux::Color const&  color,
                        std::string const& label,
+                       int text_size,
                        double horizMargin,
                        Alignment alignment)
 {
@@ -1358,6 +1360,11 @@
   else
     desc = pango_font_description_from_string(fontName);
 
+  if (text_size > 0)
+  {
+    pango_font_description_set_absolute_size(desc, text_size * PANGO_SCALE);
+  }
+
   PangoWeight weight;
   switch (regular_text_weight_)
   {
@@ -1428,6 +1435,7 @@
   pango_layout_get_extents(layout, &ink, &log);
   x = horizMargin; // let pango alignment handle the x position
   y = ((double) h - pango_units_to_double(log.height)) / 2.0;
+  
   cairo_move_to(cr, x, y);
   pango_cairo_show_layout(cr, layout);
 
@@ -1530,7 +1538,9 @@
   cairo_set_operator(cr, old);
 }
 
-bool Style::Button(cairo_t* cr, nux::ButtonVisualState state, std::string const& label, Alignment alignment)
+bool Style::Button(cairo_t* cr, nux::ButtonVisualState state, 
+                   std::string const& label, int font_size,
+                   Alignment alignment, bool zeromargin)
 {
   // sanity checks
   if (cairo_status(cr) != CAIRO_STATUS_SUCCESS)
@@ -1539,8 +1549,10 @@
   if (cairo_surface_get_type(cairo_get_target(cr)) != CAIRO_SURFACE_TYPE_IMAGE)
     return false;
 
-  unsigned int garnish = GetButtonGarnishSize();
-
+  unsigned int garnish = 0;
+  if (zeromargin == false)
+   garnish = GetButtonGarnishSize();
+  
   //ButtonOutlinePath(cr, true);
   double w = cairo_image_surface_get_width(cairo_get_target(cr));
   double h = cairo_image_surface_get_height(cairo_get_target(cr));
@@ -1571,7 +1583,6 @@
     cairo_fill_preserve(cr);
   }
   cairo_set_source_rgba(cr, pimpl->button_label_border_color_[state]);
-  //cairo_set_line_width(cr, pimpl->button_label_border_size_[state]);
   cairo_stroke(cr);
 
   pimpl->DrawOverlay(cr,
@@ -1582,12 +1593,133 @@
   pimpl->Text(cr,
               pimpl->button_label_text_color_[state],
               label,
+              font_size,
               10.0,
               alignment);
 
   return true;
 }
 
+bool Style::SquareButton(cairo_t* cr, nux::ButtonVisualState state, 
+                         std::string const& label, bool curve_bottom,
+                         int font_size, Alignment alignment, 
+                         bool zeromargin)
+{
+  // sanity checks
+  if (cairo_status(cr) != CAIRO_STATUS_SUCCESS)
+    return false;
+
+  if (cairo_surface_get_type(cairo_get_target(cr)) != CAIRO_SURFACE_TYPE_IMAGE)
+    return false;
+
+  unsigned int garnish = 0;
+  if (zeromargin == false)
+    garnish = GetButtonGarnishSize();
+  
+  double w = cairo_image_surface_get_width(cairo_get_target(cr));
+  double h = cairo_image_surface_get_height(cairo_get_target(cr));
+
+  double x = garnish;
+  double y = garnish;
+
+  double width = w - (2.0 * garnish) - 1.0;
+  double height = h - (2.0 * garnish) - 1.0;
+
+  bool odd = true;
+  double radius = 7.0;
+  
+  // draw the grid background
+  {
+    cairo_set_line_width(cr, 1);
+    cairo_move_to(cr, _align(x + width, odd), _align(y, odd));
+    if (curve_bottom)
+    {
+      LOG_DEBUG(logger) << "curve: " << _align(x + width, odd) << " - " << _align(y + height - radius, odd);
+      // line to bottom-right corner
+      cairo_line_to(cr, _align(x + width, odd), _align(y + height - radius, odd));
+
+      // line to bottom-right, left of the corner
+      cairo_arc(cr,
+                _align(x + width - radius, odd),
+                _align(y + height - radius, odd),
+                radius,
+                0.0f * G_PI / 180.0f,
+                90.0f * G_PI / 180.0f);
+
+      // line to bottom-left, right of the corner
+      cairo_line_to(cr, _align(x + radius, odd), _align(y + height, odd));
+
+      // line to bottom-left, above the corner
+      cairo_arc(cr,
+                _align(x + radius, odd),
+                _align(y + height - radius, odd),
+                radius,
+                90.0f * G_PI / 180.0f,
+                180.0f * G_PI / 180.0f);
+ 
+      // line to top
+      cairo_line_to(cr, _align(x, odd), _align(y, odd));
+    }
+    else
+    {
+      cairo_line_to(cr, _align(x + width, odd), _align(y + height, odd));
+      cairo_line_to(cr, _align(x, odd), _align(x + height, odd));
+      cairo_line_to(cr, _align(x, odd), _align(y, odd));
+    }
+
+    cairo_set_source_rgba(cr, pimpl->button_label_border_color_[nux::ButtonVisualState::VISUAL_STATE_NORMAL]);
+    cairo_stroke(cr);
+  } 
+
+  cairo_set_line_width(cr, pimpl->button_label_border_size_[state]);
+  odd = cairo_get_line_width(cr) == 2.0 ? false : true;
+
+  
+  if (pimpl->button_label_border_size_[state] == 2.0)
+  {
+    x += 1;
+    y += 1;
+    width -= 1.0;
+    height -= 1.0;
+  }
+
+  if (state == nux::ButtonVisualState::VISUAL_STATE_PRESSED)
+  {
+    RoundedRect(cr,
+                1.0,
+                _align(x, odd), _align(y, odd),
+                5.0,
+                _align(width, odd), _align(height, odd));
+
+    if (pimpl->button_label_fill_color_[state].alpha != 0.0)
+    {
+      cairo_set_source_rgba(cr, pimpl->button_label_fill_color_[state]);
+      cairo_fill_preserve(cr);
+    }
+    cairo_set_source_rgba(cr, pimpl->button_label_border_color_[state]);
+    cairo_stroke(cr);
+  }
+
+  pimpl->DrawOverlay(cr,
+                     pimpl->button_label_overlay_opacity_[state],
+                     pimpl->button_label_overlay_mode_[state],
+                     pimpl->button_label_blur_size_[state] * 0.75);
+
+  // FIXME - magic value of 42 here for the offset in the HUD,
+  // replace with a nicer style system that lets hud override 
+  // default values when it needs to
+  pimpl->Text(cr,
+              pimpl->button_label_text_color_[state],
+              label,
+              font_size,
+              42.0 + 10.0,
+              alignment);
+
+  cairo_surface_write_to_png(cairo_get_target(cr), "/tmp/wut.png");
+  
+  return true;
+}
+
 bool Style::StarEmpty(cairo_t* cr, nux::ButtonVisualState state)
 {
   // sanity checks

=== modified file 'plugins/unityshell/src/DashStyle.h'
--- plugins/unityshell/src/DashStyle.h	2012-01-19 11:51:57 +0000
+++ plugins/unityshell/src/DashStyle.h	2012-02-06 11:00:29 +0000
@@ -87,8 +87,15 @@
   static Style& Instance();
 
   virtual bool Button(cairo_t* cr, nux::ButtonVisualState state,
-                      std::string const& label,
-                      Alignment alignment = Alignment::CENTER); 
+                      std::string const& label, int font_size=-1,
+                      Alignment alignment = Alignment::CENTER,
+                      bool zeromargin=false); 
+  
+  virtual bool SquareButton(cairo_t* cr, nux::ButtonVisualState state,
+                            std::string const& label, bool curve_bottom, 
+                            int font_size=-1,
+                            Alignment alignment = Alignment::CENTER,
+                            bool zeromargin=false);
 
   virtual bool StarEmpty(cairo_t* cr, nux::ButtonVisualState state);
 

=== modified file 'plugins/unityshell/src/DashView.h'
--- plugins/unityshell/src/DashView.h	2012-01-27 06:58:20 +0000
+++ plugins/unityshell/src/DashView.h	2012-02-06 11:00:29 +0000
@@ -30,7 +30,7 @@
 #include <UnityCore/HomeLens.h>
 
 #include "BackgroundEffectHelper.h"
-#include "DashSearchBar.h"
+#include "SearchBar.h"
 #include "Introspectable.h"
 #include "LensBar.h"
 #include "LensView.h"

=== modified file 'plugins/unityshell/src/FilterAllButton.cpp'
--- plugins/unityshell/src/FilterAllButton.cpp	2012-01-10 14:09:12 +0000
+++ plugins/unityshell/src/FilterAllButton.cpp	2012-02-06 11:00:29 +0000
@@ -59,6 +59,7 @@
 {
   if (filter_ and Active())
     filter_->Clear();
+  QueueDraw();
 }
 
 void FilterAllButton::OnFilteringChanged(bool filtering)

=== added file 'plugins/unityshell/src/HudButton.cpp'
--- plugins/unityshell/src/HudButton.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudButton.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2011 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3, as
+ * published by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ *
+ */
+#include "config.h"
+
+#include <pango/pango.h>
+#include <pango/pangocairo.h>
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include <Nux/Nux.h>
+#include <NuxCore/Logger.h>
+#include <NuxImage/CairoGraphics.h>
+#include <NuxGraphics/NuxGraphics.h>
+#include <UnityCore/GLibWrapper.h>
+#include "DashStyle.h"
+
+#include "HudButton.h"
+
+namespace
+{
+nux::logging::Logger logger("unity.hud.HudButton");
+}
+
+namespace unity 
+{
+namespace hud 
+{
+
+
+HudButton::HudButton (nux::TextureArea *image, NUX_FILE_LINE_DECL)
+    : nux::Button (image, NUX_FILE_LINE_PARAM)
+    , is_rounded(false)
+    , is_focused_(false)
+{
+  InitTheme();
+  key_nav_focus_change.connect([this](nux::Area *area, bool recieving, nux::KeyNavDirection direction){ QueueDraw(); });
+}
+
+HudButton::HudButton (const std::string label_, NUX_FILE_LINE_DECL)
+    : nux::Button (NUX_FILE_LINE_PARAM)
+    , is_rounded(false)
+    , is_focused_(false)
+{
+  InitTheme();
+}
+
+HudButton::HudButton (const std::string label_, nux::TextureArea *image, NUX_FILE_LINE_DECL)
+    : nux::Button (image, NUX_FILE_LINE_PARAM)
+    , is_rounded(false)
+    , is_focused_(false)
+{
+  InitTheme();
+}
+
+HudButton::HudButton (NUX_FILE_LINE_DECL)
+    : nux::Button (NUX_FILE_LINE_PARAM)
+    , is_rounded(false)
+    , is_focused_(false)
+{
+  InitTheme();
+}
+
+HudButton::~HudButton() {
+}
+
+void HudButton::InitTheme()
+{
+  is_rounded.changed.connect([&] (bool rounded)
+  {
+    nux::Geometry geo = GetGeometry();
+    prelight_->Invalidate(geo);
+    active_->Invalidate(geo);
+    normal_->Invalidate(geo);
+  });
+
+  SetMinimumHeight(42);
+  if (!active_)
+  {
+    nux::Geometry const& geo = GetGeometry();
+
+    prelight_.reset(new nux::CairoWrapper(geo, sigc::bind(sigc::mem_fun(this, &HudButton::RedrawTheme), nux::ButtonVisualState::VISUAL_STATE_PRELIGHT)));
+    active_.reset(new nux::CairoWrapper(geo, sigc::bind(sigc::mem_fun(this, &HudButton::RedrawTheme), nux::ButtonVisualState::VISUAL_STATE_PRESSED)));
+    normal_.reset(new nux::CairoWrapper(geo, sigc::bind(sigc::mem_fun(this, &HudButton::RedrawTheme), nux::ButtonVisualState::VISUAL_STATE_NORMAL)));
+  }
+}
+
+void HudButton::RedrawTheme(nux::Geometry const& geom, cairo_t* cr, nux::ButtonVisualState faked_state)
+{
+  dash::Style::Instance().SquareButton(cr, faked_state, label_, 
+                                           is_rounded, 17, 
+                                           dash::Alignment::LEFT, true);
+}
+
+bool HudButton::AcceptKeyNavFocus()
+{
+  return true;
+}
+
+
+long HudButton::ComputeContentSize ()
+{
+  long ret = nux::Button::ComputeContentSize();
+  nux::Geometry const& geo = GetGeometry();
+
+  if (cached_geometry_ != geo)
+  {
+    prelight_->Invalidate(geo);
+    active_->Invalidate(geo);
+    normal_->Invalidate(geo);
+
+    cached_geometry_ = geo;
+  }
+  
+  return ret;
+} 
+
+void HudButton::Draw(nux::GraphicsEngine& GfxContext, bool force_draw) 
+{
+  nux::Geometry const& geo = GetGeometry();
+  gPainter.PaintBackground(GfxContext, geo);
+  // set up our texture mode
+  nux::TexCoordXForm texxform;
+  texxform.SetWrap(nux::TEXWRAP_CLAMP, nux::TEXWRAP_CLAMP);
+  texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+  // clear what is behind us
+  unsigned int alpha = 0, src = 0, dest = 0;
+  GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
+  GfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
+  GfxContext.GetRenderStates().SetBlend(true);
+  
+  nux::Color col = nux::color::Black;
+  col.alpha = 0;
+  GfxContext.QRP_Color(geo.x,
+                       geo.y,
+                       geo.width,
+                       geo.height,
+                       col);
+
+  nux::BaseTexture* texture = normal_->GetTexture();
+  if (HasKeyFocus())
+    texture = active_->GetTexture();
+  else if (HasKeyFocus())
+    texture = prelight_->GetTexture();
+  else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRESSED)
+    texture = active_->GetTexture();
+
+  GfxContext.QRP_1Tex(geo.x,
+                      geo.y,
+                      texture->GetWidth() + 1, // FIXME !! - jay, nux has gone crazy, unless i specify +1 here, it won't render the entire texture
+                      texture->GetHeight(),
+                      texture->GetDeviceTexture(),
+                      texxform,
+                      nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+  GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
+}
+
+void HudButton::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw) {
+}
+
+void HudButton::PostDraw(nux::GraphicsEngine& GfxContext, bool force_draw) {
+  nux::Button::PostDraw(GfxContext, force_draw);
+}
+
+void HudButton::SetQuery(Query::Ptr query)
+{
+  query_ = query;
+  label_ = query->formatted_text;
+  label = query->formatted_text;
+}
+
+Query::Ptr HudButton::GetQuery()
+{
+  return query_;
+}
+
+// Introspectable
+std::string HudButton::GetName() const
+{
+  return "HudButton";
+}
+
+void HudButton::AddProperties(GVariantBuilder* builder)
+{
+  g_variant_builder_add(builder, "{sv}", "label", g_variant_new_string(label_.c_str()));
+}
+
+}
+}

=== added file 'plugins/unityshell/src/HudButton.h'
--- plugins/unityshell/src/HudButton.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudButton.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2011 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3, as
+ * published by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ *
+ */
+
+
+
+#ifndef FILTERBASICBUTTON_H
+#define FILTERBASICBUTTON_H
+
+#include <Nux/Nux.h>
+#include <Nux/CairoWrapper.h>
+#include <Nux/Button.h>
+#include <Nux/TextureArea.h>
+#include <UnityCore/Hud.h>
+#include "Introspectable.h"
+
+namespace unity {
+namespace hud {
+class HudButton : public nux::Button, public unity::debug::Introspectable 
+{
+  typedef nux::ObjectPtr<nux::BaseTexture> BaseTexturePtr;
+public:
+  typedef nux::ObjectPtr<HudButton> Ptr;
+  HudButton (nux::TextureArea *image, NUX_FILE_LINE_PROTO);
+  HudButton (const std::string label, NUX_FILE_LINE_PROTO);
+  HudButton (const std::string label, nux::TextureArea *image, NUX_FILE_LINE_PROTO);
+  HudButton (NUX_FILE_LINE_PROTO);
+  virtual ~HudButton();
+
+  void SetQuery(Query::Ptr query);
+  std::shared_ptr<Query> GetQuery();
+
+  nux::Property<std::string> label;
+  nux::Property<std::string> hint;
+  nux::Property<bool> is_rounded;
+protected:
+
+  virtual bool AcceptKeyNavFocus();
+  virtual long ComputeContentSize();
+  virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  virtual void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
+  virtual void PostDraw(nux::GraphicsEngine& GfxContext, bool force_draw);
+
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+  
+  void InitTheme ();
+  void RedrawTheme(nux::Geometry const& geom, cairo_t* cr, nux::ButtonVisualState faked_state);
+  typedef std::unique_ptr<nux::CairoWrapper> NuxCairoPtr;
+
+  NuxCairoPtr prelight_;
+  NuxCairoPtr active_;
+  NuxCairoPtr normal_;
+
+private:
+  std::string label_;
+
+  Query::Ptr query_;
+  nux::Geometry cached_geometry_;
+  bool is_focused_;
+};
+}
+}
+#endif // FILTERBASICBUTTON_H

=== added file 'plugins/unityshell/src/HudController.cpp'
--- plugins/unityshell/src/HudController.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudController.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,385 @@
+/*
+ * 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: Gord Allott <[e-mail]>
+ */
+
+#include "HudController.h"
+
+#include <NuxCore/Logger.h>
+#include <Nux/HLayout.h>
+#include "PluginAdapter.h"
+#include "UBusMessages.h"
+#include "UScreen.h"
+namespace unity
+{
+namespace hud
+{
+
+namespace
+{
+nux::logging::Logger logger("unity.hud.controller");
+}
+
+Controller::Controller()
+  : launcher_width(66)
+  , panel_height(24)
+  , hud_service_("com.canonical.hud", "/com/canonical/hud")
+  , window_(0)
+  , visible_(false)
+  , need_show_(false)
+  , timeline_id_(0)
+  , last_opacity_(0.0f)
+  , start_time_(0)
+{
+  LOG_DEBUG(logger) << "hud startup";
+  SetupRelayoutCallbacks();
+
+  ubus.RegisterInterest(UBUS_HUD_CLOSE_REQUEST, sigc::mem_fun(this, &Controller::OnExternalHideHud));
+
+  //!!FIXME!! - just hijacks the dash close request so we get some more requests than normal,
+  ubus.RegisterInterest(UBUS_PLACE_VIEW_CLOSE_REQUEST, sigc::mem_fun(this, &Controller::OnExternalHideHud));
+
+  ubus.RegisterInterest(UBUS_OVERLAY_SHOWN, [&] (GVariant *data) {
+    unity::glib::String overlay_identity;
+    gboolean can_maximise = FALSE;
+    gint32 overlay_monitor = 0;
+    g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING, &overlay_identity, &can_maximise, &overlay_monitor);
+
+    if (g_strcmp0(overlay_identity, "hud"))
+    {
+      HideHud(true);
+    }
+  });
+
+  PluginAdapter::Default()->compiz_screen_ungrabbed.connect(sigc::mem_fun(this, &Controller::OnScreenUngrabbed));
+
+  hud_service_.queries_updated.connect(sigc::mem_fun(this, &Controller::OnQueriesFinished));
+  EnsureHud();
+}
+
+Controller::~Controller()
+{
+  if (window_)
+    window_->UnReference();
+  window_ = 0;
+
+  g_source_remove(timeline_id_);
+  g_source_remove(ensure_id_);
+}
+
+void Controller::SetupWindow()
+{
+  window_ = new nux::BaseWindow("Hud");
+  window_->SinkReference();
+  window_->SetBackgroundColor(nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+  window_->SetConfigureNotifyCallback(&Controller::OnWindowConfigure, this);
+  window_->ShowWindow(false);
+  window_->SetOpacity(0.0f);
+  window_->mouse_down_outside_pointer_grab_area.connect(sigc::mem_fun(this, &Controller::OnMouseDownOutsideWindow));
+}
+
+void Controller::SetupHudView()
+{
+  LOG_DEBUG(logger) << "SetupHudView called";
+  view_ = new View();
+
+  layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
+  layout_->AddView(view_, 1);
+  window_->SetLayout(layout_);
+
+  view_->mouse_down_outside_pointer_grab_area.connect(sigc::mem_fun(this, &Controller::OnMouseDownOutsideWindow));
+
+  LOG_DEBUG(logger) << "connecting to signals";
+  view_->search_changed.connect(sigc::mem_fun(this, &Controller::OnSearchChanged));
+  view_->search_activated.connect(sigc::mem_fun(this, &Controller::OnSearchActivated));
+  view_->query_activated.connect(sigc::mem_fun(this, &Controller::OnQueryActivated));
+  view_->query_selected.connect(sigc::mem_fun(this, &Controller::OnQuerySelected));
+}
+
+void Controller::SetupRelayoutCallbacks()
+{
+  GdkScreen* screen = gdk_screen_get_default();
+
+  sig_manager_.Add(new glib::Signal<void, GdkScreen*>(screen,
+    "monitors-changed", sigc::mem_fun(this, &Controller::Relayout)));
+  sig_manager_.Add(new glib::Signal<void, GdkScreen*>(screen,
+    "size-changed", sigc::mem_fun(this, &Controller::Relayout)));
+}
+
+void Controller::EnsureHud()
+{
+  if (window_)
+    return;
+
+  LOG_DEBUG(logger) << "Initializing Hud";
+
+  SetupWindow();
+  SetupHudView();
+  Relayout();
+  ensure_id_ = 0;
+}
+
+nux::BaseWindow* Controller::window() const
+{
+  return window_;
+}
+
+// We update the @geo that's sent in with our desired width and height
+void Controller::OnWindowConfigure(int window_width, int window_height,
+                                       nux::Geometry& geo, void* data)
+{
+  Controller* self = static_cast<Controller*>(data);
+  geo = self->GetIdealWindowGeometry();
+}
+
+nux::Geometry Controller::GetIdealWindowGeometry()
+{
+   UScreen *uscreen = UScreen::GetDefault();
+   int primary_monitor = uscreen->GetPrimaryMonitor();
+   auto monitor_geo = uscreen->GetMonitorGeometry(primary_monitor);
+
+   // We want to cover as much of the screen as possible to grab any mouse events outside
+   // of our window
+   return nux::Geometry (monitor_geo.x,
+                         monitor_geo.y + panel_height,
+                         monitor_geo.width,
+                         monitor_geo.height - panel_height);
+}
+
+void Controller::Relayout(GdkScreen*screen)
+{
+  EnsureHud();
+  nux::Geometry content_geo = view_->GetGeometry();
+  nux::Geometry geo = GetIdealWindowGeometry();
+
+  window_->SetGeometry(geo);
+  layout_->SetMinMaxSize(content_geo.width, content_geo.height);
+  view_->SetWindowGeometry(window_->GetAbsoluteGeometry(), window_->GetGeometry());
+  view_->Relayout();
+}
+
+void Controller::OnMouseDownOutsideWindow(int x, int y,
+                                              unsigned long bflags, unsigned long kflags)
+{
+  LOG_DEBUG(logger) << "OnMouseDownOutsideWindow called";
+  HideHud();
+}
+
+void Controller::OnScreenUngrabbed()
+{
+  LOG_DEBUG(logger) << "OnScreenUngrabbed called";
+  if (need_show_)
+  {
+    EnsureHud();
+    ShowHud();
+  }
+}
+
+void Controller::OnExternalShowHud(GVariant* variant)
+{
+  EnsureHud();
+  visible_ ? HideHud() : ShowHud();
+}
+
+void Controller::OnExternalHideHud(GVariant* variant)
+{
+  LOG_DEBUG(logger) << "External Hiding the hud";
+  EnsureHud();
+  HideHud();
+}
+
+void Controller::ShowHideHud()
+{
+  EnsureHud();
+  visible_ ? HideHud(true) : ShowHud();
+}
+
+bool Controller::IsVisible()
+{
+  return visible_;
+}
+
+void Controller::ShowHud()
+{
+  LOG_DEBUG(logger) << "Showing the hud";
+  EnsureHud();
+  view_->AboutToShow();
+
+  window_->ShowWindow(true);
+  window_->PushToFront();
+  window_->EnableInputWindow(true, "Hud", true, false);
+  window_->SetInputFocus();
+  nux::GetWindowCompositor().SetKeyFocusArea(view_->default_focus());
+  window_->CaptureMouseDownAnyWhereElse(true);
+  view_->CaptureMouseDownAnyWhereElse(true);
+  window_->QueueDraw();
+
+  view_->ResetToDefault();
+ 
+  view_->SetIcon("");
+  hud_service_.RequestQuery("");
+  need_show_ = false;
+  visible_ = true;
+
+  StartShowHideTimeline();
+  view_->SetWindowGeometry(window_->GetAbsoluteGeometry(), window_->GetGeometry());
+
+  // hide the launcher
+  GVariant* message_data = g_variant_new("(b)", TRUE);
+  ubus.SendMessage(UBUS_LAUNCHER_LOCK_HIDE, message_data);
+
+  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "hud", FALSE, 0);
+  ubus.SendMessage(UBUS_OVERLAY_SHOWN, info);
+}
+void Controller::HideHud(bool restore)
+{
+  LOG_DEBUG (logger) << "hiding the hud";
+  if (visible_ == false)
+    return;
+
+  EnsureHud();
+  view_->AboutToHide();
+  window_->CaptureMouseDownAnyWhereElse(false);
+  window_->EnableInputWindow(false, "Hud", true, false);
+  visible_ = false;
+
+  StartShowHideTimeline();
+
+  restore = true;
+  if (restore)
+    PluginAdapter::Default ()->restoreInputFocus ();
+
+  hud_service_.CloseQuery();
+
+  //unhide the launcher
+  GVariant* message_data = g_variant_new("(b)", FALSE);
+  ubus.SendMessage(UBUS_LAUNCHER_LOCK_HIDE, message_data);
+  
+  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "hud", FALSE, 0);
+  ubus.SendMessage(UBUS_OVERLAY_HIDDEN, info);
+}
+
+void Controller::StartShowHideTimeline()
+{
+  EnsureHud();
+
+  if (timeline_id_)
+    g_source_remove(timeline_id_);
+
+  timeline_id_ = g_timeout_add(15, (GSourceFunc)Controller::OnViewShowHideFrame, this);
+  last_opacity_ = window_->GetOpacity();
+  start_time_ = g_get_monotonic_time();
+
+}
+
+gboolean Controller::OnViewShowHideFrame(Controller* self)
+{
+#define _LENGTH_ 90000
+  float diff = g_get_monotonic_time() - self->start_time_;
+  float progress = diff / (float)_LENGTH_;
+  float last_opacity = self->last_opacity_;
+
+  if (self->visible_)
+  {
+    self->window_->SetOpacity(last_opacity + ((1.0f - last_opacity) * progress));
+  }
+  else
+  {
+    self->window_->SetOpacity(last_opacity - (last_opacity * progress));
+  }
+
+  if (diff > _LENGTH_)
+  {
+    self->timeline_id_ = 0;
+
+    // Make sure the state is right
+    self->window_->SetOpacity(self->visible_ ? 1.0f : 0.0f);
+    if (!self->visible_)
+    {
+      self->window_->ShowWindow(false);
+    }
+
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+void Controller::OnActivateRequest(GVariant* variant)
+{
+  EnsureHud();
+  ShowHud();
+}
+
+void Controller::OnSearchChanged(std::string search_string)
+{
+  LOG_DEBUG(logger) << "Search Changed";
+  hud_service_.RequestQuery(search_string);
+}
+
+void Controller::OnSearchActivated(std::string search_string)
+{
+  unsigned int timestamp = nux::GetWindowThread()->GetGraphicsDisplay().GetCurrentEvent().x11_timestamp;
+  hud_service_.ExecuteQueryBySearch(search_string, timestamp);
+  HideHud();
+}
+
+void Controller::OnQueryActivated(Query::Ptr query)
+{
+  LOG_DEBUG(logger) << "Activating query, " << query->formatted_text;
+  unsigned int timestamp = nux::GetWindowThread()->GetGraphicsDisplay().GetCurrentEvent().x11_timestamp;
+  hud_service_.ExecuteQuery(query, timestamp); 
+  HideHud();
+}
+
+void Controller::OnQuerySelected(Query::Ptr query)
+{
+  LOG_DEBUG(logger) << "Selected query, " << query->formatted_text;
+  view_->SetIcon(query->icon_name);
+}
+
+
+void Controller::OnQueriesFinished(Hud::Queries queries)
+{
+  view_->SetQueries(queries);
+  std::string icon_name = "";
+  for (auto query = queries.begin(); query != queries.end(); query++)
+  {
+    if (!(*query)->icon_name.empty())
+    {
+      icon_name = (*query)->icon_name;
+      break;
+    }
+  }
+  
+  LOG_DEBUG(logger) << "setting icon to - " << icon_name;
+  view_->SetIcon(icon_name);
+}
+
+// Introspectable
+std::string Controller::GetName() const
+{
+  return "HudController";
+}
+
+void Controller::AddProperties(GVariantBuilder* builder)
+{
+  g_variant_builder_add(builder, "{sv}", "visible", g_variant_new_boolean (visible_));
+}
+
+
+}
+}

=== added file 'plugins/unityshell/src/HudController.h'
--- plugins/unityshell/src/HudController.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudController.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,113 @@
+/*
+ * 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_HUD_CONTROLLER_H_
+#define UNITY_HUD_CONTROLLER_H_
+
+#include <memory>
+
+#include <gdk/gdk.h>
+#include <UnityCore/GLibSignal.h>
+#include <UnityCore/Hud.h>
+
+#include <NuxCore/Property.h>
+#include <NuxGraphics/GraphicsEngine.h>
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+
+#include "HudView.h"
+#include "UBusWrapper.h"
+
+namespace unity
+{
+namespace hud
+{
+
+class Controller : public unity::debug::Introspectable
+{
+public:
+  typedef std::shared_ptr<Controller> Ptr;
+
+  Controller();
+  ~Controller();
+
+  nux::BaseWindow* window() const;
+
+  nux::Property<int> launcher_width;
+  nux::Property<int> panel_height;
+
+  void ShowHideHud();
+  void ShowHud();
+  void HideHud(bool restore_focus = true);
+  bool IsVisible();
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  void EnsureHud();
+  void SetupWindow();
+  void SetupHudView();
+  void SetupRelayoutCallbacks();
+  void RegisterUBusInterests();
+
+  nux::Geometry GetIdealWindowGeometry();
+  void Relayout(GdkScreen*screen=NULL);
+
+  void OnMouseDownOutsideWindow(int x, int y, unsigned long bflags, unsigned long kflags);
+  void OnScreenUngrabbed();
+  void OnExternalShowHud(GVariant* variant);
+  void OnExternalHideHud(GVariant* variant);
+  void OnActivateRequest(GVariant* variant);
+
+  void OnSearchChanged(std::string search_string);
+  void OnSearchActivated(std::string search_string);
+  void OnQueryActivated(Query::Ptr query);
+  void OnQuerySelected(Query::Ptr query);
+
+
+private:
+  void StartShowHideTimeline();
+  static gboolean OnViewShowHideFrame(Controller* self);
+
+  static void OnWindowConfigure(int width, int height, nux::Geometry& geo, void* data);
+
+  void OnQueriesFinished(Hud::Queries queries);
+
+private:
+  UBusManager ubus;
+  Hud hud_service_;
+  glib::SignalManager sig_manager_;
+  nux::BaseWindow* window_;
+  bool visible_;
+  bool need_show_;
+
+  guint timeline_id_;
+  float last_opacity_;
+  gint64 start_time_;
+
+  View* view_;
+  guint ensure_id_;
+
+  nux::Layout* layout_;
+};
+
+
+}
+}
+#endif

=== added file 'plugins/unityshell/src/HudIcon.cpp'
--- plugins/unityshell/src/HudIcon.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudIcon.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,95 @@
+/*
+ * 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: Gord Allott <[e-mail]>
+ */
+
+
+#include "HudIcon.h"
+#include "NuxCore/Logger.h"
+namespace
+{
+  nux::logging::Logger logger("unity.hud.icon");
+}
+  
+namespace unity
+{
+namespace hud
+{
+
+Icon::Icon(nux::BaseTexture* texture, guint width, guint height)
+  : unity::IconTexture(texture, width, height)
+{
+  Init();
+  icon_renderer_.SetTargetSize(54, 46, 0);
+}
+
+Icon::Icon(const char* icon_name, unsigned int size, bool defer_icon_loading)
+  : unity::IconTexture(icon_name, size, defer_icon_loading)
+{
+  Init();
+}
+
+Icon::~Icon()
+{
+}
+
+void Icon::Init()
+{
+  SetMinimumWidth(66);
+  SetMinimumHeight(66);
+  background_ = nux::CreateTexture2DFromFile(PKGDATADIR"/launcher_icon_back_54.png", -1, true);
+  gloss_ = nux::CreateTexture2DFromFile(PKGDATADIR"/launcher_icon_shine_54.png", -1, true);
+  edge_ = nux::CreateTexture2DFromFile(PKGDATADIR"/launcher_icon_edge_54.png", -1,  true);
+  
+  texture_updated.connect([&] (nux::BaseTexture* texture) 
+  {
+    icon_texture_source_ = new HudIconTextureSource(nux::ObjectPtr<nux::BaseTexture>(texture));
+    icon_texture_source_->ColorForIcon(_pixbuf_cached);
+    QueueDraw();
+    LOG_DEBUG(logger) << "got our texture";
+  });
+}
+
+void Icon::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  if (texture() == nullptr)
+    return;
+
+  unity::ui::RenderArg arg;
+  arg.icon = icon_texture_source_.GetPointer();
+  arg.colorify            = nux::color::White;
+  arg.running_arrow       = true;
+  arg.running_on_viewport = true;
+  arg.render_center       = nux::Point3(32, 32, 0);
+  arg.logical_center      = nux::Point3(52, 50, 0);
+  arg.window_indicators   = true;
+  arg.backlight_intensity = 1.0f;
+  arg.alpha               = 1.0f;
+  
+  std::list<unity::ui::RenderArg> args;
+  args.push_front(arg);
+
+  
+  auto toplevel = GetToplevel(); 
+  icon_renderer_.SetTargetSize(54, 46, 0);
+  icon_renderer_.PreprocessIcons(args, toplevel->GetGeometry());
+  icon_renderer_.RenderIcon(GfxContext, arg, toplevel->GetGeometry(), toplevel->GetGeometry());
+}
+
+
+}
+}
+

=== added file 'plugins/unityshell/src/HudIcon.h'
--- plugins/unityshell/src/HudIcon.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudIcon.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,73 @@
+// -*- 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: Gord Allott <[e-mail]>
+ *
+ */
+
+#ifndef HUDICON_H
+#define HUDICON_H
+
+#include <set>
+#include <string>
+
+#include "config.h"
+
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+#include <NuxCore/Math/MathInc.h>
+
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+
+#include <gtk/gtk.h>
+
+#include "IconTexture.h"
+#include "HudIconTextureSource.h"
+#include "IconRenderer.h"
+#include "Introspectable.h"
+
+namespace unity
+{
+namespace hud
+{
+
+class Icon : public unity::IconTexture
+{
+public:
+  typedef nux::ObjectPtr<IconTexture> Ptr;  
+  Icon(nux::BaseTexture* texture, guint width, guint height);
+  Icon(const char* icon_name, unsigned int size, bool defer_icon_loading = false);
+  ~Icon();
+
+protected:
+  void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  void Init();
+
+  nux::ObjectPtr<nux::BaseTexture> background_;
+  nux::ObjectPtr<nux::BaseTexture> gloss_;
+  nux::ObjectPtr<nux::BaseTexture> edge_;
+  nux::ObjectPtr<HudIconTextureSource> icon_texture_source_;
+  unity::ui::IconRenderer icon_renderer_;
+};
+
+}
+
+}
+
+#endif /* HUDICON_H */

=== added file 'plugins/unityshell/src/HudIconTextureSource.cpp'
--- plugins/unityshell/src/HudIconTextureSource.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudIconTextureSource.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,110 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ */
+
+
+#include "HudIconTextureSource.h"
+#include "config.h"
+
+#include <glib.h>
+
+#include <Nux/Nux.h>
+#include <NuxCore/Logger.h>
+
+
+namespace unity
+{
+namespace hud
+{
+
+HudIconTextureSource::HudIconTextureSource(nux::ObjectPtr<nux::BaseTexture> texture)
+  : unity::ui::IconTextureSource()
+  , icon_texture_(texture)
+{
+}
+
+HudIconTextureSource::~HudIconTextureSource()
+{
+}
+
+void HudIconTextureSource::ColorForIcon(GdkPixbuf* pixbuf)
+{
+  unsigned int width = gdk_pixbuf_get_width(pixbuf);
+  unsigned int height = gdk_pixbuf_get_height(pixbuf);
+  unsigned int row_bytes = gdk_pixbuf_get_rowstride(pixbuf);
+  
+  long int rtotal = 0, gtotal = 0, btotal = 0;
+  float total = 0.0f;
+  
+  guchar* img = gdk_pixbuf_get_pixels(pixbuf);
+  
+  for (unsigned int i = 0; i < width; i++)
+  {
+    for (unsigned int j = 0; j < height; j++)
+    {
+      guchar* pixels = img + (j * row_bytes + i * 4);
+      guchar r = *(pixels + 0);
+      guchar g = *(pixels + 1);
+      guchar b = *(pixels + 2);
+      guchar a = *(pixels + 3);
+      
+      float saturation = (MAX(r, MAX(g, b)) - MIN(r, MIN(g, b))) / 255.0f;
+      float relevance = .1 + .9 * (a / 255.0f) * saturation;
+      
+      rtotal += (guchar)(r * relevance);
+      gtotal += (guchar)(g * relevance);
+      btotal += (guchar)(b * relevance);
+      
+      total += relevance * 255;
+    }
+  }
+  
+  nux::color::RedGreenBlue rgb(rtotal / total,
+                               gtotal / total,
+                               btotal / total);
+  nux::color::HueSaturationValue hsv(rgb);
+  
+  if (hsv.saturation > 0.15f)
+    hsv.saturation = 0.65f;
+  
+  hsv.value = 0.90f;
+  bg_color = nux::Color(nux::color::RedGreenBlue(hsv));
+}
+
+nux::Color HudIconTextureSource::BackgroundColor()
+{
+  return bg_color;
+}
+
+nux::BaseTexture* HudIconTextureSource::TextureForSize(int size)
+{
+  return icon_texture_.GetPointer();
+}
+
+nux::Color HudIconTextureSource::GlowColor()
+{
+ return nux::Color(0.0f, 0.0f, 0.0f, 0.0f); 
+}
+
+nux::BaseTexture* HudIconTextureSource::Emblem()
+{
+  return nullptr;
+}
+
+}
+}
\ No newline at end of file

=== added file 'plugins/unityshell/src/HudIconTextureSource.h'
--- plugins/unityshell/src/HudIconTextureSource.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudIconTextureSource.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,51 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ */
+
+
+#ifndef HUDICONTEXTURESOURCE_H
+#define HUDICONTEXTURESOURCE_H
+
+#include "IconTextureSource.h"
+
+namespace unity
+{
+namespace hud
+{
+
+class HudIconTextureSource : public unity::ui::IconTextureSource
+{
+public:
+  HudIconTextureSource(nux::ObjectPtr<nux::BaseTexture> texture);
+  ~HudIconTextureSource();
+  
+  virtual nux::Color BackgroundColor();
+  virtual nux::BaseTexture* TextureForSize(int size);
+  virtual nux::Color GlowColor();
+  virtual nux::BaseTexture* Emblem();
+  void ColorForIcon(GdkPixbuf* pixbuf);
+  
+private:
+  nux::Color bg_color;
+  nux::ObjectPtr<nux::BaseTexture> icon_texture_;
+};
+
+}
+}
+
+#endif // HUDICONTEXTURESOURCE_H

=== added file 'plugins/unityshell/src/HudView.cpp'
--- plugins/unityshell/src/HudView.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudView.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,398 @@
+/*
+ * 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: Gord Allott <[e-mail]>
+ */
+
+#include "HudView.h"
+
+#include <math.h>
+
+#include <gio/gdesktopappinfo.h>
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+#include <Nux/Button.h>
+#include <iostream>
+#include <sstream>
+
+#include <NuxCore/Logger.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/RadioOptionFilter.h>
+#include <Nux/HLayout.h>
+#include <Nux/LayeredLayout.h>
+
+#include <NuxCore/Logger.h>
+#include "HudButton.h"
+#include "UBusMessages.h"
+#include "DashStyle.h"
+
+namespace unity
+{
+namespace hud
+{
+
+namespace
+{
+nux::logging::Logger logger("unity.hud.view");
+int icon_size = 42;
+const std::string default_text = _("Type your command");
+}
+
+NUX_IMPLEMENT_OBJECT_TYPE(View);
+
+View::View()
+  : nux::View(NUX_TRACKER_LOCATION)
+  , button_views_(NULL)
+{
+  renderer_.SetOwner(this);
+  renderer_.need_redraw.connect([this] () { 
+    QueueDraw();
+  });
+
+  nux::ROPConfig rop;
+  rop.Blend = true;
+  rop.SrcBlend = GL_ONE;
+  rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+  SetupViews();
+  search_bar_->key_down.connect (sigc::mem_fun (this, &View::OnKeyDown));
+
+  search_bar_->activated.connect ([&]() {
+    search_activated.emit(search_bar_->search_string);
+  });
+
+  mouse_down.connect(sigc::mem_fun(this, &View::OnMouseButtonDown));
+  
+  Relayout();
+
+}
+
+View::~View()
+{
+  RemoveChild(search_bar_.GetPointer());
+  for (auto button = buttons_.begin(); button != buttons_.end(); button++)
+  {
+    RemoveChild((*button).GetPointer());
+  }
+}
+
+void View::ResetToDefault()
+{
+  search_bar_->search_string = "";
+  search_bar_->search_hint = default_text;
+}
+
+void View::Relayout()
+{
+  nux::Geometry geo = GetGeometry();
+  content_geo_ = GetBestFitGeometry(geo);
+  LOG_DEBUG(logger) << "content_geo: " << content_geo_.width << "x" << content_geo_.height;
+
+  layout_->SetMinMaxSize(content_geo_.width, content_geo_.height);
+
+  QueueDraw();
+}
+
+long View::PostLayoutManagement(long LayoutResult)
+{
+  Relayout();
+  return LayoutResult;
+}
+
+
+nux::View* View::default_focus() const
+{
+  return search_bar_->text_entry();
+}
+
+void View::SetQueries(Hud::Queries queries)
+{
+  // remove the previous children
+  for (auto button = buttons_.begin(); button != buttons_.end(); button++)
+  {
+    RemoveChild((*button).GetPointer());
+  }
+  
+  queries_ = queries_;
+  buttons_.clear();
+  button_views_->Clear();
+  int found_items = 0;
+  for (auto query = queries.begin(); query != queries.end(); query++)
+  {
+    if (found_items > 5)
+      break;
+
+    HudButton::Ptr button = HudButton::Ptr(new HudButton());
+    buttons_.push_front(button);
+    button->SetQuery(*query);
+    button_views_->AddView(button.GetPointer(), 0, nux::MINOR_POSITION_LEFT);
+
+    button->click.connect([&](nux::View* view) {
+      query_activated.emit(dynamic_cast<HudButton*>(view)->GetQuery());
+    });
+    
+    button->key_nav_focus_activate.connect([&](nux::Area *area) {
+      query_activated.emit(dynamic_cast<HudButton*>(area)->GetQuery());
+    });
+
+    button->key_nav_focus_change.connect([&](nux::Area *area, bool recieving, KeyNavDirection direction){
+      if (recieving)
+        query_selected.emit(dynamic_cast<HudButton*>(area)->GetQuery());
+    });
+
+    button->is_rounded = (query == --(queries.end())) ? true : false;
+    button->SetMinimumWidth(941);
+    found_items++;
+  }
+  
+  QueueRelayout();
+  QueueDraw();
+}
+
+void View::SetIcon(std::string icon_name)
+{
+  LOG_DEBUG(logger) << "Setting icon to " << icon_name;
+  icon_->SetByIconName(icon_name.c_str(), icon_size);
+  QueueDraw();
+}
+
+// Gives us the width and height of the contents that will give us the best "fit",
+// which means that the icons/views will not have uneccessary padding, everything will
+// look tight
+nux::Geometry View::GetBestFitGeometry(nux::Geometry const& for_geo)
+{
+  //FIXME - remove magic values, replace with scalable text depending on DPI 
+  // requires smarter font settings really...
+  int width, height = 0;
+  width = 1024;
+  height = 276;
+  
+  LOG_DEBUG (logger) << "best fit is, " << width << ", " << height;
+
+  return nux::Geometry(0, 0, width, height);
+}
+
+void View::AboutToShow()
+{
+  renderer_.AboutToShow();
+}
+
+void View::AboutToHide()
+{
+  renderer_.AboutToHide();
+}
+
+void View::SetWindowGeometry(nux::Geometry const& absolute_geo, nux::Geometry const& geo)
+{
+  window_geometry_ = geo;
+  window_geometry_.x = 0;
+  window_geometry_.y = 0;
+  absolute_window_geometry_ = absolute_geo;
+}
+
+namespace
+{
+  const int top_spacing = 9;
+  const int content_width = 941;
+  const int icon_vertical_margin = 5;
+  const int spacing_between_icon_and_content = 8;
+}
+
+void View::SetupViews()
+{
+  layout_ = new nux::HLayout();
+  
+  icon_ = new Icon("", icon_size, true);
+  nux::Layout* icon_layout = new nux::VLayout();
+  icon_layout->SetVerticalExternalMargin(icon_vertical_margin);
+  icon_layout->AddView(icon_.GetPointer(), 0, nux::MINOR_POSITION_LEFT, nux::MINOR_SIZE_FULL);
+  layout_->AddLayout(icon_layout, 0, nux::MINOR_POSITION_TOP, nux::MINOR_SIZE_MATCHCONTENT);
+  layout_->AddLayout(new nux::SpaceLayout(spacing_between_icon_and_content,
+                                          spacing_between_icon_and_content,
+                                          spacing_between_icon_and_content,
+                                          spacing_between_icon_and_content), 0);
+  
+  
+  content_layout_ = new nux::VLayout();
+  layout_->AddLayout(content_layout_.GetPointer(), 1, nux::MINOR_POSITION_TOP);
+  SetLayout(layout_.GetPointer());
+
+  // add the top spacing 
+  content_layout_->AddLayout(new nux::SpaceLayout(top_spacing,top_spacing,top_spacing,top_spacing), 0);
+
+  // add the search bar to the composite
+  search_bar_ = new unity::SearchBar(content_width, true);
+  search_bar_->disable_glow = true;
+  search_bar_->search_hint = default_text;
+  search_bar_->search_changed.connect(sigc::mem_fun(this, &View::OnSearchChanged));
+  AddChild(search_bar_.GetPointer());
+  content_layout_->AddView(search_bar_.GetPointer(), 0, nux::MINOR_POSITION_LEFT);
+ 
+  button_views_ = new nux::VLayout();
+  button_views_->SetMaximumWidth(content_width);
+
+  content_layout_->AddLayout(button_views_.GetPointer(), 1, nux::MINOR_POSITION_LEFT);
+}
+
+void View::OnSearchChanged(std::string const& search_string)
+{
+  LOG_DEBUG(logger) << "got search change";
+  search_changed.emit(search_string);
+  if (search_string.empty())
+  {
+    search_bar_->search_hint = default_text;
+  }
+  else
+  {
+    search_bar_->search_hint = "";
+  }
+}
+
+
+void View::OnKeyDown (unsigned long event_type, unsigned long keysym,
+                      unsigned long event_state, const TCHAR* character,
+                      unsigned short key_repeat_count)
+{
+  if (keysym == NUX_VK_ESCAPE)
+  {
+    LOG_DEBUG(logger) << "got escape key";
+    ubus.SendMessage(UBUS_HUD_CLOSE_REQUEST);
+  }
+}
+
+void View::OnMouseButtonDown(int x, int y, unsigned long button, unsigned long key)
+{
+  if (!content_geo_.IsPointInside(x, y))
+  {
+    ubus.SendMessage(UBUS_HUD_CLOSE_REQUEST);
+  }
+}
+
+void View::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
+{
+  renderer_.DrawFull(gfx_context, layout_->GetGeometry(), absolute_window_geometry_, window_geometry_, true);
+}
+
+void View::DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw)
+{
+  renderer_.DrawInner(gfx_context, layout_->GetGeometry(), absolute_window_geometry_, window_geometry_);
+  
+  if (IsFullRedraw())
+  {
+    nux::GetPainter().PushBackgroundStack();
+    layout_->ProcessDraw(gfx_context, force_draw);
+    nux::GetPainter().PopBackgroundStack();
+  }
+  else
+  {
+    layout_->ProcessDraw(gfx_context, force_draw);
+  }
+
+  renderer_.DrawInnerCleanup(gfx_context, layout_->GetGeometry(), absolute_window_geometry_, window_geometry_);
+}
+
+// Keyboard navigation
+bool View::AcceptKeyNavFocus()
+{
+  return false;
+}
+
+// Introspectable
+std::string View::GetName() const
+{
+  return "HudView";
+}
+
+void View::AddProperties(GVariantBuilder* builder)
+{
+    
+}
+
+bool View::InspectKeyEvent(unsigned int eventType,
+                           unsigned int key_sym,
+                           const char* character)
+{
+  if ((eventType == nux::NUX_KEYDOWN) && (key_sym == NUX_VK_ESCAPE))
+  {
+    if (search_bar_->search_string == "")
+    {
+      ubus.SendMessage(UBUS_HUD_CLOSE_REQUEST);
+    }
+    else
+    {
+      search_bar_->search_string = "";
+      search_bar_->search_hint = default_text;
+    }
+    return true;
+  }
+  return false;
+}
+
+nux::Area* View::FindKeyFocusArea(unsigned int key_symbol,
+      unsigned long x11_key_code,
+      unsigned long special_keys_state)
+{
+  // Do what nux::View does, but if the event isn't a key navigation,
+  // designate the text entry to process it.
+
+  nux::KeyNavDirection direction = nux::KEY_NAV_NONE;
+  switch (x11_key_code)
+  {
+  case NUX_VK_UP:
+    direction = nux::KEY_NAV_UP;
+    break;
+  case NUX_VK_DOWN:
+    direction = nux::KEY_NAV_DOWN;
+    break;
+  case NUX_VK_LEFT:
+    direction = nux::KEY_NAV_LEFT;
+    break;
+  case NUX_VK_RIGHT:
+    direction = nux::KEY_NAV_RIGHT;
+    break;
+  case NUX_VK_LEFT_TAB:
+    direction = nux::KEY_NAV_TAB_PREVIOUS;
+    break;
+  case NUX_VK_TAB:
+    direction = nux::KEY_NAV_TAB_NEXT;
+    break;
+  case NUX_VK_ENTER:
+  case NUX_KP_ENTER:
+    // Not sure if Enter should be a navigation key
+    direction = nux::KEY_NAV_ENTER;
+    break;
+  default:
+    direction = nux::KEY_NAV_NONE;
+    break;
+  }
+
+  if (has_key_focus_)
+  {
+    return this;
+  }
+  else if (direction == nux::KEY_NAV_NONE)
+  {
+    // then send the event to the search entry
+    return search_bar_->text_entry();
+  }
+  else if (next_object_to_key_focus_area_)
+  {
+    return next_object_to_key_focus_area_->FindKeyFocusArea(key_symbol, x11_key_code, special_keys_state);
+  }
+  return NULL;
+}
+
+}
+}

=== added file 'plugins/unityshell/src/HudView.h'
--- plugins/unityshell/src/HudView.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudView.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,118 @@
+/*
+ * 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: Gordon Allott <[e-mail]>
+ */
+
+#ifndef UNITY_HUD_VIEW_H_
+#define UNITY_HUD_VIEW_H_
+
+#include <string>
+
+#include <NuxGraphics/GraphicsEngine.h>
+#include <Nux/Nux.h>
+#include <Nux/PaintLayer.h>
+#include <Nux/View.h>
+#include <Nux/VLayout.h>
+#include <StaticCairoText.h>
+
+#include <glib.h>
+
+#include <UnityCore/Hud.h>
+#include "Introspectable.h"
+
+#include "UBusWrapper.h"
+#include "HudIcon.h"
+#include "HudButton.h"
+#include "SearchBar.h"
+#include "OverlayRenderer.h"
+
+namespace unity
+{
+namespace hud
+{
+
+class View : public nux::View, public unity::debug::Introspectable
+{
+  NUX_DECLARE_OBJECT_TYPE(HudView, nux::View);
+  typedef nux::ObjectPtr<View> Ptr;
+public:
+  View();
+  ~View();
+
+  void ResetToDefault();
+
+  void Relayout();
+  nux::View* default_focus() const;
+
+  void SetQueries(Hud::Queries queries);
+  void SetIcon(std::string icon_name);
+  
+  void AboutToShow();
+  void AboutToHide();
+
+  void SetWindowGeometry(nux::Geometry const& absolute_geo, nux::Geometry const& geo);
+
+  sigc::signal<void, std::string> search_changed;
+  sigc::signal<void, std::string> search_activated;
+  sigc::signal<void, Query::Ptr> query_activated;
+  sigc::signal<void, Query::Ptr> query_selected;
+  
+protected:
+  virtual Area* FindKeyFocusArea(unsigned int key_symbol,
+  unsigned long x11_key_code,
+  unsigned long special_keys_state);
+
+  void SetupViews();
+  void OnSearchChanged(std::string const& search_string);
+  virtual long PostLayoutManagement(long LayoutResult);
+private:
+  void OnMouseButtonDown(int x, int y, unsigned long button, unsigned long key);
+  void OnKeyDown (unsigned long event_type, unsigned long event_keysym,
+                                unsigned long event_state, const TCHAR* character,
+                                unsigned short key_repeat_count);
+  void Draw(nux::GraphicsEngine& gfx_context, bool force_draw);
+  void DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw);
+  bool InspectKeyEvent(unsigned int eventType, unsigned int key_sym, const char* character);
+  bool AcceptKeyNavFocus();
+  nux::Geometry GetBestFitGeometry(nux::Geometry const& for_geo);
+
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  UBusManager ubus;
+  nux::ObjectPtr<nux::Layout> layout_;
+  nux::ObjectPtr<nux::Layout> content_layout_;
+  nux::ObjectPtr<nux::VLayout> button_views_;
+  std::list<HudButton::Ptr> buttons_;
+  
+  //FIXME - replace with dash search bar once modifications to dash search bar land
+  SearchBar::Ptr search_bar_;
+  Icon::Ptr icon_;
+  bool visible_;
+
+  Hud::Queries queries_;
+  nux::Geometry content_geo_;
+  OverlayRenderer renderer_;
+  nux::Geometry window_geometry_;
+  nux::Geometry absolute_window_geometry_;
+};
+
+
+}
+}
+#endif
+

=== modified file 'plugins/unityshell/src/IMTextEntry.cpp'
--- plugins/unityshell/src/IMTextEntry.cpp	2012-01-26 12:59:18 +0000
+++ plugins/unityshell/src/IMTextEntry.cpp	2012-02-06 11:00:29 +0000
@@ -27,12 +27,10 @@
 
 namespace unity
 {
-namespace dash
-{
 
 namespace
 {
-nux::logging::Logger logger("unity.dash.imtextentry");
+nux::logging::Logger logger("unity.imtextentry");
 }
 
 NUX_IMPLEMENT_OBJECT_TYPE(IMTextEntry);
@@ -338,4 +336,3 @@
 }
 
 }
-}

=== modified file 'plugins/unityshell/src/IMTextEntry.h'
--- plugins/unityshell/src/IMTextEntry.h	2012-01-03 00:51:51 +0000
+++ plugins/unityshell/src/IMTextEntry.h	2012-02-06 11:00:29 +0000
@@ -30,8 +30,6 @@
 
 namespace unity
 {
-namespace dash
-{
 
 using namespace unity::glib;
 using namespace nux;
@@ -80,6 +78,5 @@
 };
 
 }
-}
 
 #endif

=== modified file 'plugins/unityshell/src/IconTexture.cpp'
--- plugins/unityshell/src/IconTexture.cpp	2011-11-08 18:21:44 +0000
+++ plugins/unityshell/src/IconTexture.cpp	2012-02-06 11:00:29 +0000
@@ -24,6 +24,7 @@
 #include <pango/pangocairo.h>
 
 #include <Nux/Nux.h>
+#include <NuxCore/Logger.h>
 #include <NuxGraphics/GLThread.h>
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/Variant.h>
@@ -37,6 +38,7 @@
 namespace
 {
 const char* const DEFAULT_ICON = "text-x-preview";
+nux::logging::Logger logger("unity.icontexture");
 }
 
 using namespace unity;
@@ -67,7 +69,7 @@
 {
   _icon_name = g_strdup(icon_name ? icon_name : DEFAULT_ICON);
 
-  if (!g_strcmp0(_icon_name, "") == 0 && !defer_icon_loading)
+  if (g_strcmp0(_icon_name, "") != 0 && !defer_icon_loading)
     LoadIcon();
 }
 
@@ -95,8 +97,11 @@
 
 void IconTexture::LoadIcon()
 {
-  static const char* const DEFAULT_GICON = ". GThemedIcon text-x-preview";
-
+  LOG_DEBUG(logger) << "LoadIcon called (" << _icon_name << ") - loading: " << _loading;
+static const char* const DEFAULT_GICON = ". GThemedIcon text-x-preview";
+  if (!g_strcmp0(_icon_name, ""))
+    return;
+ 
   if (_loading)
     return;
   _loading = true;
@@ -144,6 +149,7 @@
                                       _texture_height,
                                       sigc::mem_fun(this, &IconTexture::CreateTextureCallback));
   QueueDraw();
+  _loading = false;
 }
 
 void IconTexture::IconLoaded(std::string const& icon_name, unsigned size,
@@ -162,6 +168,9 @@
     if (icon_name != DEFAULT_ICON)
       SetByIconName(DEFAULT_ICON, _size);
   }
+
+  texture_updated.emit(_texture_cached.GetPointer());
+  QueueDraw();
 }
 
 void IconTexture::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)

=== modified file 'plugins/unityshell/src/IconTexture.h'
--- plugins/unityshell/src/IconTexture.h	2011-12-08 01:23:11 +0000
+++ plugins/unityshell/src/IconTexture.h	2012-02-06 11:00:29 +0000
@@ -53,6 +53,8 @@
 
   nux::BaseTexture* texture();
 
+  sigc::signal<void, nux::BaseTexture*> texture_updated;
+  
 protected:
   // Key navigation
   virtual bool AcceptKeyNavFocus();
@@ -61,7 +63,8 @@
   std::string GetName() const;
   void AddProperties(GVariantBuilder* builder);
   virtual bool DoCanFocus();
-
+  GdkPixbuf*        _pixbuf_cached;
+  
 protected:
   void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
 
@@ -74,7 +77,7 @@
   char* _icon_name;
   unsigned int _size;
 
-  GdkPixbuf*        _pixbuf_cached;
+
   nux::ObjectPtr<nux::BaseTexture> _texture_cached;
   // FIXME: make these two a nux::Size.
   int               _texture_width;

=== modified file 'plugins/unityshell/src/OverlayRenderer.cpp'
--- plugins/unityshell/src/OverlayRenderer.cpp	2012-02-03 21:56:04 +0000
+++ plugins/unityshell/src/OverlayRenderer.cpp	2012-02-06 11:00:29 +0000
@@ -50,7 +50,7 @@
   void Init();
   void OnBackgroundColorChanged(GVariant* args);
   
-  void Draw(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geometry);
+  void Draw(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geometry, bool force_draw);
   void DrawContent(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geometry);
   void DrawContentCleanup(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geometry);
   
@@ -118,12 +118,12 @@
   parent->need_redraw.emit();
 }
 
-void OverlayRendererImpl::Draw(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geometry)
+void OverlayRendererImpl::Draw(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geometry, bool force_edges)
 {
   bool paint_blur = BackgroundEffectHelper::blur_type != BLUR_NONE;
   nux::Geometry geo = content_geo;
 
-  if (dash::Settings::Instance().GetFormFactor() != dash::FormFactor::NETBOOK)
+  if (dash::Settings::Instance().GetFormFactor() != dash::FormFactor::NETBOOK || force_edges)
   {
     // Paint the edges
     {
@@ -475,9 +475,9 @@
   pimpl_->bg_effect_helper_.blur_type = BLUR_NONE;
 }
 
-void OverlayRenderer::DrawFull(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geo)
+void OverlayRenderer::DrawFull(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geo, bool force_edges)
 {
-  pimpl_->Draw(gfx_context, content_geo, absolute_geo, geo);
+  pimpl_->Draw(gfx_context, content_geo, absolute_geo, geo, force_edges);
 }
 
 void OverlayRenderer::DrawInner(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geo)

=== modified file 'plugins/unityshell/src/OverlayRenderer.h'
--- plugins/unityshell/src/OverlayRenderer.h	2012-01-27 06:58:20 +0000
+++ plugins/unityshell/src/OverlayRenderer.h	2012-02-06 11:00:29 +0000
@@ -70,7 +70,7 @@
    * absolute_geo: your views GetAbsoluteGeometry()
    * geo: your views GetGeometry()
    */
-  void DrawFull(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geo);
+  void DrawFull(nux::GraphicsEngine& gfx_context, nux::Geometry content_geo, nux::Geometry absolute_geo, nux::Geometry geo, bool force_edges=false);
   
   /*
    * Draws just the stack that is overlay behind the inner_geometry using push/pop layers, call in DrawContent() before drawing your content

=== renamed file 'plugins/unityshell/src/DashSearchBar.cpp' => 'plugins/unityshell/src/SearchBar.cpp'
--- plugins/unityshell/src/DashSearchBar.cpp	2012-01-26 22:17:41 +0000
+++ plugins/unityshell/src/SearchBar.cpp	2012-02-06 11:00:29 +0000
@@ -25,6 +25,7 @@
 #include <Nux/VLayout.h>
 #include <Nux/Layout.h>
 #include <Nux/WindowCompositor.h>
+#include <NuxCore/Logger.h>
 
 #include <NuxImage/CairoGraphics.h>
 #include <NuxImage/ImageSurface.h>
@@ -36,7 +37,7 @@
 #include <glib.h>
 #include <glib/gi18n-lib.h>
 
-#include "DashSearchBar.h"
+#include "SearchBar.h"
 #include <UnityCore/Variant.h>
 
 #include "CairoTexture.h"
@@ -48,12 +49,17 @@
 namespace
 {
 const float kExpandDefaultIconOpacity = 1.0f;
+const int external_margin_vertical = 8;
+const int external_margin_horizontal = 7;
+}
+
+namespace
+{
+  nux::logging::Logger logger("unity");
 }
 
 namespace unity
 {
-namespace dash
-{
 
 NUX_IMPLEMENT_OBJECT_TYPE(SearchBar);
 
@@ -62,18 +68,53 @@
   , search_hint("")
   , showing_filters(false)
   , can_refine_search(false)
+  , disable_glow(false)
+  , show_filter_hint_(true)
   , search_bar_width_(642)
   , live_search_timeout_(0)
   , start_spinner_timeout_(0)
 {
+  Init();
+}
+
+SearchBar::SearchBar(int search_bar_width, bool show_filter_hint_, NUX_FILE_LINE_DECL)
+  : View(NUX_FILE_LINE_PARAM)
+  , search_hint("")
+  , showing_filters(false)
+  , can_refine_search(false)
+  , disable_glow(false)
+  , show_filter_hint_(show_filter_hint_)
+  , search_bar_width_(search_bar_width)
+  , live_search_timeout_(0)
+  , start_spinner_timeout_(0)
+{
+  Init();
+}
+
+SearchBar::SearchBar(int search_bar_width, NUX_FILE_LINE_DECL)
+  : View(NUX_FILE_LINE_PARAM)
+  , search_hint("")
+  , showing_filters(false)
+  , can_refine_search(false)
+  , disable_glow(false)
+  , show_filter_hint_(true)
+  , search_bar_width_(search_bar_width)
+  , live_search_timeout_(0)
+  , start_spinner_timeout_(0)
+{
+  Init();
+}
+
+void SearchBar::Init()
+{
   nux::BaseTexture* icon = dash::Style::Instance().GetSearchMagnifyIcon();
 
   bg_layer_ = new nux::ColorLayer(nux::Color(0xff595853), true);
 
   layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
   layout_->SetHorizontalInternalMargin(0);
-  layout_->SetVerticalExternalMargin(8);
-  layout_->SetHorizontalExternalMargin(7);
+  layout_->SetVerticalExternalMargin(external_margin_vertical);
+  layout_->SetHorizontalExternalMargin(external_margin_horizontal);
   SetLayout(layout_);
 
   spinner_ = new SearchBarSpinner();
@@ -102,42 +143,44 @@
   layered_layout_->SetMaximumWidth(search_bar_width_);
   layout_->AddView(layered_layout_, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
 
-  std::string filter_str = _("<small><b>Filter results</b></small>");
-  show_filters_ = new nux::StaticCairoText(filter_str.c_str());
-  show_filters_->SetVisible(false);
-  show_filters_->SetFont("Ubuntu 10");
-  show_filters_->SetTextColor(nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
-  show_filters_->SetTextAlignment(nux::StaticCairoText::NUX_ALIGN_LEFT);
-  show_filters_->mouse_click.connect([&] (int x, int y, unsigned long b, unsigned long k) { showing_filters = !showing_filters; });
-
-  nux::BaseTexture* arrow;
-  arrow = dash::Style::Instance().GetGroupExpandIcon();
-  expand_icon_ = new IconTexture(arrow,
-                                 arrow->GetWidth(),
-                                 arrow->GetHeight());
-  expand_icon_->SetOpacity(kExpandDefaultIconOpacity);
-  expand_icon_->SetMinimumSize(arrow->GetWidth(), arrow->GetHeight());
-  expand_icon_->SetVisible(false);
-  expand_icon_->mouse_click.connect([&] (int x, int y, unsigned long b, unsigned long k) { showing_filters = !showing_filters; });
-
-  filter_layout_ = new nux::HLayout();
-  filter_layout_->SetHorizontalInternalMargin(8);
-  filter_layout_->SetHorizontalExternalMargin(6);
-  filter_space_ = new nux::SpaceLayout(100, 10000, 0, 1);
-  filter_layout_->AddLayout(filter_space_, 1);
-  filter_layout_->AddView(show_filters_, 0, nux::MINOR_POSITION_CENTER);
-
-  arrow_layout_  = new nux::VLayout();
-  arrow_top_space_ = new nux::SpaceLayout(2, 2, 12, 12);
-  arrow_bottom_space_ = new nux::SpaceLayout(2, 2, 8, 8);
-  arrow_layout_->AddView(arrow_top_space_, 0, nux::MINOR_POSITION_CENTER);
-  arrow_layout_->AddView(expand_icon_, 0, nux::MINOR_POSITION_CENTER);
-  arrow_layout_->AddView(arrow_bottom_space_, 0, nux::MINOR_POSITION_CENTER);
-
-  filter_layout_->AddView(arrow_layout_, 0, nux::MINOR_POSITION_CENTER);
-
-  layout_->AddView(filter_layout_, 1, nux::MINOR_POSITION_RIGHT, nux::MINOR_SIZE_FULL);
-
+  if (show_filter_hint_)
+  {
+    std::string filter_str = _("<small><b>Filter results</b></small>");
+    show_filters_ = new nux::StaticCairoText(filter_str.c_str());
+    show_filters_->SetVisible(false);
+    show_filters_->SetFont("Ubuntu 10");
+    show_filters_->SetTextColor(nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
+    show_filters_->SetTextAlignment(nux::StaticCairoText::NUX_ALIGN_LEFT);
+    show_filters_->mouse_click.connect([&] (int x, int y, unsigned long b, unsigned long k) { showing_filters = !showing_filters; });
+
+    nux::BaseTexture* arrow;
+    arrow = dash::Style::Instance().GetGroupExpandIcon();
+    expand_icon_ = new IconTexture(arrow,
+                                   arrow->GetWidth(),
+                                   arrow->GetHeight());
+    expand_icon_->SetOpacity(kExpandDefaultIconOpacity);
+    expand_icon_->SetMinimumSize(arrow->GetWidth(), arrow->GetHeight());
+    expand_icon_->SetVisible(false);
+    expand_icon_->mouse_click.connect([&] (int x, int y, unsigned long b, unsigned long k) { showing_filters = !showing_filters; });
+
+    filter_layout_ = new nux::HLayout();
+    filter_layout_->SetHorizontalInternalMargin(8);
+    filter_layout_->SetHorizontalExternalMargin(6);
+    filter_space_ = new nux::SpaceLayout(100, 10000, 0, 1);
+    filter_layout_->AddLayout(filter_space_, 1);
+    filter_layout_->AddView(show_filters_, 0, nux::MINOR_POSITION_CENTER);
+
+    arrow_layout_  = new nux::VLayout();
+    arrow_top_space_ = new nux::SpaceLayout(2, 2, 12, 12);
+    arrow_bottom_space_ = new nux::SpaceLayout(2, 2, 8, 8);
+    arrow_layout_->AddView(arrow_top_space_, 0, nux::MINOR_POSITION_CENTER);
+    arrow_layout_->AddView(expand_icon_, 0, nux::MINOR_POSITION_CENTER);
+    arrow_layout_->AddView(arrow_bottom_space_, 0, nux::MINOR_POSITION_CENTER);
+
+    filter_layout_->AddView(arrow_layout_, 0, nux::MINOR_POSITION_CENTER);
+
+    layout_->AddView(filter_layout_, 1, nux::MINOR_POSITION_RIGHT, nux::MINOR_SIZE_FULL);
+  }
   sig_manager_.Add(new Signal<void, GtkSettings*, GParamSpec*>
       (gtk_settings_get_default(),
        "notify::gtk-font-name",
@@ -151,9 +194,21 @@
   showing_filters.changed.connect(sigc::mem_fun(this, &SearchBar::OnShowingFiltersChanged));
   can_refine_search.changed.connect([&] (bool can_refine)
   {
-    show_filters_->SetVisible(can_refine);
-    expand_icon_->SetVisible(can_refine);
-  });
+    if (show_filter_hint_)
+    {
+      show_filters_->SetVisible(can_refine);
+      expand_icon_->SetVisible(can_refine);
+    }
+  });
+
+  disable_glow.changed.connect([&](bool disabled) 
+  {
+    layout_->SetVerticalExternalMargin(0);
+    layout_->SetHorizontalExternalMargin(0);
+    UpdateBackground(true);
+    QueueDraw();
+  });
+
 }
 
 SearchBar::~SearchBar()
@@ -259,18 +314,21 @@
 
 void SearchBar::OnShowingFiltersChanged(bool is_showing)
 {
-  dash::Style& style = dash::Style::Instance();
-  if (is_showing)
-    expand_icon_->SetTexture(style.GetGroupUnexpandIcon());
-  else
-    expand_icon_->SetTexture(style.GetGroupExpandIcon());
+  if (show_filter_hint_)
+  {
+    dash::Style& style = dash::Style::Instance();
+    if (is_showing)
+      expand_icon_->SetTexture(style.GetGroupUnexpandIcon());
+    else
+      expand_icon_->SetTexture(style.GetGroupExpandIcon());
+  }
 }
 
 void SearchBar::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
   nux::Geometry geo = GetGeometry();
 
-  UpdateBackground();
+  UpdateBackground(false);
 
   GfxContext.PushClippingRectangle(geo);
 
@@ -344,21 +402,33 @@
   spinner_->SetState(is_empty ? STATE_READY : STATE_CLEAR);
 }
 
-void SearchBar::UpdateBackground()
+void SearchBar::UpdateBackground(bool force)
 {
-#define PADDING 12
-#define RADIUS  5
+  int PADDING = 12;
+  int RADIUS = 5;
   int x, y, width, height;
   nux::Geometry geo = GetGeometry();
   geo.width = layered_layout_->GetGeometry().width;
 
-  if (geo.width == last_width_ && geo.height == last_height_)
+  LOG_DEBUG(logger) << "height: " 
+  << geo.height << " - "
+  << layered_layout_->GetGeometry().height << " - " 
+  << pango_entry_->GetGeometry().height;
+
+  if (geo.width == last_width_ 
+      && geo.height == last_height_ 
+      && force == false)
     return;
 
   last_width_ = geo.width;
   last_height_ = geo.height;
 
+  if (disable_glow)
+    PADDING = 2;
+  
+  
   x = y = PADDING - 1;
+  
   width = last_width_ - (2 * PADDING);
   height = last_height_ - (2 * PADDING) + 1;
 
@@ -473,5 +543,4 @@
   g_variant_builder_add (builder, "{sv}", "search_string", g_variant_new_string (pango_entry_->GetText().c_str()) );
 }
 
-} // namespace dash
 } // namespace unity

=== renamed file 'plugins/unityshell/src/DashSearchBar.h' => 'plugins/unityshell/src/SearchBar.h'
--- plugins/unityshell/src/DashSearchBar.h	2012-01-17 15:39:16 +0000
+++ plugins/unityshell/src/SearchBar.h	2012-02-06 11:00:29 +0000
@@ -17,8 +17,8 @@
  * Authored by: Neil Jagdish Patel <[e-mail]>
  */
 
-#ifndef DASH_SEARCH_BAR_H
-#define DASH_SEARCH_BAR_H
+#ifndef SEARCH_BAR_H
+#define SEARCH_BAR_H
 
 #include <gtk/gtk.h>
 
@@ -32,7 +32,7 @@
 #include <Nux/TextEntry.h>
 #include <UnityCore/GLibSignal.h>
 
-#include "DashSearchBarSpinner.h"
+#include "SearchBarSpinner.h"
 #include "IconTexture.h"
 #include "IMTextEntry.h"
 #include "Introspectable.h"
@@ -40,8 +40,6 @@
 
 namespace unity
 {
-namespace dash
-{
 
 using namespace unity::glib;
 
@@ -49,7 +47,10 @@
 {
   NUX_DECLARE_OBJECT_TYPE(SearchBar, nux::View);
 public:
+  typedef nux::ObjectPtr<SearchBar> Ptr;
   SearchBar(NUX_FILE_LINE_PROTO);
+  SearchBar(int search_width, bool show_filter_hint, NUX_FILE_LINE_PROTO);
+  SearchBar(int search_width, NUX_FILE_LINE_PROTO);
   ~SearchBar();
 
   void SearchFinished();
@@ -59,6 +60,7 @@
   nux::Property<std::string> search_hint;
   nux::Property<bool> showing_filters;
   nux::Property<bool> can_refine_search;
+  nux::Property<bool> disable_glow;
   nux::ROProperty<bool> im_active;
 
   sigc::signal<void> activated;
@@ -67,6 +69,8 @@
 
 private:
 
+  void Init();
+
   void OnFontChanged(GtkSettings* settings, GParamSpec* pspec=NULL);
   void OnSearchHintChanged();
 
@@ -76,7 +80,7 @@
   void OnMouseButtonDown(int x, int y, unsigned long button_flags, unsigned long key_flags);
   void OnEndKeyFocus();
 
-  void UpdateBackground();
+  void UpdateBackground(bool force);
   void OnSearchChanged(nux::TextEntry* text_entry);
   void OnClearClicked(int x, int y, unsigned long button_flags, unsigned long key_flags);
   void OnEntryActivated();
@@ -85,6 +89,7 @@
   std::string get_search_string() const;
   bool set_search_string(std::string const& string);
   bool get_im_active() const;
+  bool show_filter_hint_;
 
   static gboolean OnLiveSearchTimeout(SearchBar* self);
   static gboolean OnSpinnerStartCb(SearchBar* self);
@@ -110,7 +115,6 @@
   IconTexture* expand_icon_;
   int search_bar_width_;
 
-
   int last_width_;
   int last_height_;
   
@@ -121,6 +125,5 @@
 };
 
 }
-}
 
 #endif

=== renamed file 'plugins/unityshell/src/DashSearchBarSpinner.cpp' => 'plugins/unityshell/src/SearchBarSpinner.cpp'
--- plugins/unityshell/src/DashSearchBarSpinner.cpp	2011-12-16 22:10:23 +0000
+++ plugins/unityshell/src/SearchBarSpinner.cpp	2012-02-06 11:00:29 +0000
@@ -17,7 +17,7 @@
  * Authored by: Neil Jagdish Patel <[e-mail]>
  */
 
-#include "DashSearchBarSpinner.h"
+#include "SearchBarSpinner.h"
 
 #include <Nux/VLayout.h>
 
@@ -25,8 +25,6 @@
 
 namespace unity
 {
-namespace dash
-{
 
 NUX_IMPLEMENT_OBJECT_TYPE(SearchBarSpinner);
 
@@ -236,4 +234,3 @@
 }
 
 }
-}

=== renamed file 'plugins/unityshell/src/DashSearchBarSpinner.h' => 'plugins/unityshell/src/SearchBarSpinner.h'
--- plugins/unityshell/src/DashSearchBarSpinner.h	2011-12-08 01:23:11 +0000
+++ plugins/unityshell/src/SearchBarSpinner.h	2012-02-06 11:00:29 +0000
@@ -17,8 +17,8 @@
  * Authored by: Neil Jagdish Patel <[e-mail]>
  */
 
-#ifndef DASH_SEARCH_BAR_SPINNER_H
-#define DASH_SEARCH_BAR_SPINNER_H
+#ifndef SEARCH_BAR_SPINNER_H
+#define SEARCH_BAR_SPINNER_H
 
 #include <Nux/Nux.h>
 #include <Nux/View.h>
@@ -29,8 +29,6 @@
 
 namespace unity
 {
-namespace dash
-{
 
 enum SpinnerState
 {
@@ -80,6 +78,5 @@
 };
 
 }
-}
 
 #endif

=== modified file 'plugins/unityshell/src/UBusMessages.h'
--- plugins/unityshell/src/UBusMessages.h	2012-01-31 10:59:11 +0000
+++ plugins/unityshell/src/UBusMessages.h	2012-02-06 11:00:29 +0000
@@ -78,6 +78,8 @@
 // FIXME - fix the nux focus api so we don't need this
 #define UBUS_RESULT_VIEW_KEYNAV_CHANGED "RESULT_VIEW_KEYNAV_CHANGED"
 
+#define UBUS_HUD_CLOSE_REQUEST "HUD_CLOSE_REQUEST"
+
 // Signals sent when the switcher is shown, hidden or changes selection
 #define UBUS_SWITCHER_SHOWN             "SWITCHER_SHOWN"
 #define UBUS_SWITCHER_SELECTION_CHANGED "SWITCHER_SELECTION_CHANGED"

=== modified file 'plugins/unityshell/src/unity-search-bar-accessible.cpp'
--- plugins/unityshell/src/unity-search-bar-accessible.cpp	2011-09-15 13:58:42 +0000
+++ plugins/unityshell/src/unity-search-bar-accessible.cpp	2012-02-06 11:00:29 +0000
@@ -20,7 +20,7 @@
  * SECTION:unity-search_bar-accessible
  * @Title: UnitySearchBarAccessible
  * @short_description: Implementation of the ATK interfaces for #SearchBar
- * @see_also: SearchBar at DashSearchBar.h
+ * @see_also: SearchBar at SearchBar.h
  *
  * #UnitySearchBarAccessible implements the required ATK interfaces for
  * #SearchBar, ie: exposing the different SearchBarIcon on the model as
@@ -33,9 +33,9 @@
 #include "unity-search-bar-accessible.h"
 
 #include "unitya11y.h"
-#include "DashSearchBar.h"
+#include "SearchBar.h"
 
-using namespace unity::dash;
+using namespace unity;
 
 /* GObject */
 static void unity_search_bar_accessible_class_init(UnitySearchBarAccessibleClass* klass);

=== modified file 'plugins/unityshell/src/unitya11y.cpp'
--- plugins/unityshell/src/unitya11y.cpp	2011-11-07 22:28:01 +0000
+++ plugins/unityshell/src/unitya11y.cpp	2012-02-06 11:00:29 +0000
@@ -299,7 +299,7 @@
   if (object->Type().IsDerivedFromType(unity::dash::ResultViewGrid::StaticObjectType))
     return unity_rvgrid_accessible_new(object);
 
-  if (object->Type().IsDerivedFromType(unity::dash::SearchBar::StaticObjectType))
+  if (object->Type().IsDerivedFromType(unity::SearchBar::StaticObjectType))
     return unity_search_bar_accessible_new(object);
 
   if (object->Type().IsDerivedFromType(unity::switcher::SwitcherView::StaticObjectType))

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-02-04 01:55:49 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-02-06 11:00:29 +0000
@@ -52,7 +52,6 @@
 
 #include "unitya11y.h"
 
-#include "ubus-server.h"
 #include "UBusMessages.h"
 #include "UScreen.h"
 
@@ -119,6 +118,7 @@
   , dash_is_open_ (false)
   , grab_index_ (0)
   , painting_tray_ (false)
+  , last_hud_show_time_(0)
 {
   Timer timer;
   gfloat version;
@@ -258,6 +258,8 @@
      }
 #endif
 
+     optionSetShowHudInitiate(boost::bind(&UnityScreen::ShowHudInitiate, this, _1, _2, _3));
+     optionSetShowHudTerminate(boost::bind(&UnityScreen::ShowHudTerminate, this, _1, _2, _3));
      optionSetBackgroundColorNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetLauncherHideModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetBacklightModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -371,7 +373,7 @@
       sout << "<Alt>" << XKeysymToString(above_tab_keysym);
 
       screen->removeAction(&optionGetAltTabNextWindow());
-      
+
       CompAction action = CompAction();
       action.keyFromString(sout.str());
       action.setState (CompAction::StateInitKey | CompAction::StateAutoGrab);
@@ -386,7 +388,7 @@
       sout << "<Alt><Shift>" << XKeysymToString(above_tab_keysym);
 
       screen->removeAction(&optionGetAltTabPrevWindow());
-      
+
       CompAction action = CompAction();
       action.keyFromString(sout.str());
       action.setState (CompAction::StateInitKey | CompAction::StateAutoGrab);
@@ -820,8 +822,8 @@
 bool UnityScreen::forcePaintOnTop ()
 {
     return !allowWindowPaint ||
-	    ((switcher_controller_->Visible() ||
-	      dash_is_open_) && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
+      ((switcher_controller_->Visible() ||
+        dash_is_open_) && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
 }
 
 void UnityWindow::paintThumbnail (nux::Geometry const& bounding, float alpha)
@@ -967,7 +969,7 @@
 {
   if (mShowdesktopHandler)
     if (mShowdesktopHandler->animate (ms))
-    { 
+    {
       delete mShowdesktopHandler;
       mShowdesktopHandler = NULL;
       return true;
@@ -996,7 +998,7 @@
    return false;
 
   if (w->state () & (CompWindowStateSkipPagerMask |
-		     CompWindowStateSkipTaskbarMask))
+         CompWindowStateSkipTaskbarMask))
     return false;
 
   if ((w->state () & CompWindowStateHiddenMask))
@@ -1669,7 +1671,7 @@
     altTabInitiateCommon(action, state, options);
     switcher_controller_->Select(1); // always select the current application
   }
-  
+
   switcher_controller_->NextDetail();
 
   action->setState(action->state() | CompAction::StateTermKey);
@@ -1680,7 +1682,7 @@
 {
   if (switcher_controller_->Visible())
     switcher_controller_->PrevDetail();
-  
+
   return false;
 }
 
@@ -1735,6 +1737,44 @@
     PluginAdapter::Default ()->restoreInputFocus ();
 }
 
+bool UnityScreen::ShowHudInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
+{
+  // to receive the Terminate event
+  if (state & CompAction::StateInitKey)
+    action->setState(action->state() | CompAction::StateTermKey);  
+
+  last_hud_show_time_ = g_get_monotonic_time();
+
+  return false;
+}
+
+bool UnityScreen::ShowHudTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
+{
+  if (optionGetShowHud().key().toString() == action->key().toString())
+  {
+    if (switcher_controller_->Visible())
+      return false; // early exit if the switcher is open
+
+    gint64 current_time = g_get_monotonic_time();
+    if (current_time - last_hud_show_time_ < 150 * 1000)
+    {
+      if (hud_controller_->IsVisible())
+      {
+        ubus_manager_.SendMessage(UBUS_HUD_CLOSE_REQUEST);
+      }
+      else
+      {
+        hud_controller_->ShowHud();
+      }
+      last_hud_show_time_ = 0;
+    }
+  }
+
+  action->setState(action->state() & ~CompAction::StateTermKey);
+
+  return false;
+}
+
 gboolean UnityScreen::initPluginActions(gpointer data)
 {
   CompPlugin* p = CompPlugin::find("expo");
@@ -1821,7 +1861,7 @@
   bool result = screen->initPluginForScreen(p);
   if (p->vTable->name() == "unityshell")
     initAltTabNextWindow();
-    
+
   return result;
 }
 
@@ -1834,8 +1874,8 @@
   return "Unity";
 }
 
-bool isNuxWindow (CompWindow* value) 
-{ 
+bool isNuxWindow (CompWindow* value)
+{
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
   auto id = value->id();
 
@@ -1862,7 +1902,7 @@
 void UnityScreen::RaiseInputWindows()
 {
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-  
+
   for (auto window : xwns)
   {
     CompWindow* cwin = screen->findWindow(window);
@@ -1995,7 +2035,7 @@
   if (!window->onCurrentDesktop ())
     return false;
 
-  /* Only withdrawn windows 
+  /* Only withdrawn windows
    * which are marked hidden
    * are excluded */
   if (!window->shaded () &&
@@ -2003,8 +2043,8 @@
       (window->state () & CompWindowStateHiddenMask))
     return false;
 
-  if (window->geometry ().x () + window->geometry ().width ()  <= 0	||
-      window->geometry ().y () + window->geometry ().height () <= 0	||
+  if (window->geometry ().x () + window->geometry ().width ()  <= 0 ||
+      window->geometry ().y () + window->geometry ().height () <= 0 ||
       window->geometry ().x () >= (int) screen->width ()||
       window->geometry ().y () >= (int) screen->height ())
     return false;
@@ -2110,7 +2150,7 @@
       !(lastState & CompWindowStateFullscreenMask))
     UnityScreen::get (screen)->fullscreen_windows_.push_back(window);
   else if (lastState & CompWindowStateFullscreenMask &&
-	   !(window->state () & CompWindowStateFullscreenMask))
+     !(window->state () & CompWindowStateFullscreenMask))
     UnityScreen::get (screen)->fullscreen_windows_.remove(window);
 
   PluginAdapter::Default()->NotifyStateChange(window, window->state(), lastState);
@@ -2259,9 +2299,9 @@
   {
     case UnityshellOptions::BackgroundColor:
     {
-      nux::Color override_color (optionGetBackgroundColorRed() / 65535.0f, 
-                                 optionGetBackgroundColorGreen() / 65535.0f, 
-                                 optionGetBackgroundColorBlue() / 65535.0f, 
+      nux::Color override_color (optionGetBackgroundColorRed() / 65535.0f,
+                                 optionGetBackgroundColorGreen() / 65535.0f,
+                                 optionGetBackgroundColorBlue() / 65535.0f,
                                  optionGetBackgroundColorAlpha() / 65535.0f);
 
       override_color.red = override_color.red / override_color.alpha;
@@ -2309,6 +2349,7 @@
       launcher_options->icon_size = optionGetIconSize();
       launcher_options->tile_size = optionGetIconSize() + 6;
 
+      hud_controller_->launcher_width = launcher_controller_->launcher().GetAbsoluteWidth() - 1;
       /* The launcher geometry includes 1px used to draw the right margin
        * that must not be considered when drawing the dash                    */
       dash_controller_->launcher_width = launcher_controller_->launcher().GetAbsoluteWidth() - 1;
@@ -2497,6 +2538,11 @@
   /* Setup Places */
   dash_controller_.reset(new dash::Controller());
   dash_controller_->on_realize.connect(sigc::mem_fun(this, &UnityScreen::OnDashRealized));
+
+  /* Setup Hud */
+  hud_controller_.reset(new hud::Controller());
+  AddChild(hud_controller_.get());
+  LOG_INFO(logger) << "initLauncher-hud " << timer.ElapsedSeconds() << "s";
   
   // Setup Shortcut Hint
   InitHints();
@@ -2646,7 +2692,7 @@
 
   if (mShowdesktopHandler)
     delete mShowdesktopHandler;
-    
+
   if (focusdesktop_handle_)
     g_source_remove(focusdesktop_handle_);
 

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-01-29 06:08:20 +0000
+++ plugins/unityshell/src/unityshell.h	2012-02-06 11:00:29 +0000
@@ -58,6 +58,8 @@
 #include <compiztoolbox/compiztoolbox.h>
 #include <dlfcn.h>
 
+#include "HudController.h"
+
 namespace unity
 {
 
@@ -202,6 +204,9 @@
   bool altTabNextWindowInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool altTabPrevWindowInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
 
+  /* handle hud key activations */
+  bool ShowHudInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
+  bool ShowHudTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool launcherSwitcherForwardInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool launcherSwitcherPrevInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool launcherSwitcherTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options);
@@ -268,6 +273,7 @@
   dash::Controller::Ptr     dash_controller_;
   panel::Controller::Ptr    panel_controller_;
   switcher::Controller::Ptr switcher_controller_;
+  hud::Controller::Ptr      hud_controller_;
 
   shortcut::Controller::Ptr shortcut_controller_;
   std::list<shortcut::AbstractHint*> hints_;
@@ -322,6 +328,7 @@
   CompWindowList         fullscreen_windows_;
   bool                   painting_tray_;
   unsigned int           tray_paint_mask_;
+  gint64                 last_hud_show_time_;
 
 #ifndef USE_GLES
   ScreenEffectFramebufferObject::GLXGetProcAddressProc glXGetProcAddressP;
@@ -396,7 +403,7 @@
   UnityMinimizedHandler *mMinimizeHandler;
 
   UnityShowdesktopHandler             *mShowdesktopHandler;
-  
+
 private:
 
   guint  focusdesktop_handle_;

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2012-02-01 00:06:29 +0000
+++ plugins/unityshell/unityshell.xml.in	2012-02-06 11:00:29 +0000
@@ -40,9 +40,14 @@
             </requirement>
         </deps>
         <options>
-	          <group>
+            <group>
                 <_short>Behaviour</_short>
-	         <option name="launcher_hide_mode" type="int">
+                <option name="show_hud" type="key">
+                    <_short>Key to show the HUD</_short>
+                    <_long>Make the HUD appear with this key</_long>
+                    <default>&lt;Alt&gt;</default>
+                  </option>
+	              <option name="launcher_hide_mode" type="int">
                     <_short>Hide Launcher</_short>
                     <_long>Make the launcher hide automatically after some time of inactivity: always or just when the focussed window is not over the launcher</_long>
                     <min>0</min>
@@ -64,16 +69,16 @@
                         <value>3</value>
                         <_name>Dodge Active Window</_name>
                     </desc>
-	              </option>
-	              <option name="show_launcher" type="key">
+                </option>
+                <option name="show_launcher" type="key">
                     <_short>Key to show the launcher</_short>
                     <_long>Make the launcher appear with that key</_long>
                     <default>&lt;Super&gt;</default>
                   </option>
                   <option name="keyboard_focus" type="key">
-            		    <_short>Key to put keyboard-focus on launcher</_short>
-            		    <_long>Set the keyboard-focus on the launcher so it can be navigated with the cursor-keys</_long>
-            		    <default>&lt;Alt&gt;F1</default>
+                    <_short>Key to put keyboard-focus on launcher</_short>
+                    <_long>Set the keyboard-focus on the launcher so it can be navigated with the cursor-keys</_long>
+                    <default>&lt;Alt&gt;F1</default>
                   </option>
                   <option name="execute_command" type="key">
                         <_short>Key to execute a command</_short>
@@ -118,37 +123,37 @@
                       <_long>fixme</_long>
                       <default>&lt;Alt&gt;&lt;Shift&gt;Tab</default>
                 </option>
-		<option name="alt_tab_right" type="key">
-		    <_short>Go right in the switcher</_short>
-		    <_long>fixme</_long>
-		    <default>&lt;Alt&gt;Right</default>
-		    <passive_grab>false</passive_grab>
-		    <internal/>
-		</option>
-		<option name="alt_tab_left" type="key">
-		    <_short>Go left in the switcher</_short>
-		    <_long>fixme</_long>
-		    <default>&lt;Alt&gt;Left</default>
-		    <passive_grab>false</passive_grab>
-		    <internal/>
-		</option>
+    <option name="alt_tab_right" type="key">
+        <_short>Go right in the switcher</_short>
+        <_long>fixme</_long>
+        <default>&lt;Alt&gt;Right</default>
+        <passive_grab>false</passive_grab>
+        <internal/>
+    </option>
+    <option name="alt_tab_left" type="key">
+        <_short>Go left in the switcher</_short>
+        <_long>fixme</_long>
+        <default>&lt;Alt&gt;Left</default>
+        <passive_grab>false</passive_grab>
+        <internal/>
+    </option>
                 <option name="alt_tab_detail_start" type="key">
-		    <_short>Key to expose the windows in the switcher</_short>
-		    <_long>fixme</_long>
-		    <default>&lt;Alt&gt;Down</default>
-		    <passive_grab>false</passive_grab>
-		    <internal/>
+        <_short>Key to expose the windows in the switcher</_short>
+        <_long>fixme</_long>
+        <default>&lt;Alt&gt;Down</default>
+        <passive_grab>false</passive_grab>
+        <internal/>
                 </option>
-		<option name="alt_tab_detail_stop" type="key">
-		    <_short>Key to collapse windows in the switcher</_short>
-		    <_long>fixme</_long>
-		    <default>&lt;Alt&gt;Up</default>
-		    <passive_grab>false</passive_grab>
-		    <internal/>
-		</option>
+    <option name="alt_tab_detail_stop" type="key">
+        <_short>Key to collapse windows in the switcher</_short>
+        <_long>fixme</_long>
+        <default>&lt;Alt&gt;Up</default>
+        <passive_grab>false</passive_grab>
+        <internal/>
+    </option>
         <option name="alt_tab_next_window" type="key">
-		    <_short>Key to flip through windows in the switcher</_short>
-		    <_long>fixme</_long>
+        <_short>Key to flip through windows in the switcher</_short>
+        <_long>fixme</_long>
             <passive_grab>false</passive_grab>
         </option>
         <option name="alt_tab_prev_window" type="key">
@@ -156,11 +161,11 @@
             <_long>fixme</_long>
             <passive_grab>false</passive_grab>
         </option>
-		<option name="show_minimized_windows" type="bool">
-		    <_short>Show minimized windows in switcher</_short>
-		    <_long>Hack to enable minimized windows in switcher. Disable and report bugs if problems are caused</_long>
-		    <default>true</default>
-		</option>
+    <option name="show_minimized_windows" type="bool">
+        <_short>Show minimized windows in switcher</_short>
+        <_long>Hack to enable minimized windows in switcher. Disable and report bugs if problems are caused</_long>
+        <default>true</default>
+    </option>
               </group>
               <group>
                 <_short>Experimental</_short>
@@ -359,7 +364,7 @@
                     <max>100</max>
                     <default>75</default>
                 </option>
-                
+
                 <option name="devices_option" type="int">
                     <_short>Show Devices</_short>
                     <_long>Show devices in the launcher</_long>

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2012-01-24 09:02:23 +0000
+++ po/POTFILES.in	2012-02-06 11:00:29 +0000
@@ -6,7 +6,7 @@
 plugins/unityshell/src/SpacerLauncherIcon.cpp
 plugins/unityshell/src/TrashLauncherIcon.cpp
 plugins/unityshell/src/BFBLauncherIcon.cpp
-plugins/unityshell/src/DashSearchBar.cpp
+plugins/unityshell/src/SearchBar.cpp
 plugins/unityshell/src/DashView.cpp
 plugins/unityshell/src/DesktopLauncherIcon.cpp
 plugins/unityshell/src/FilterExpanderLabel.cpp

=== modified file 'standalone-clients/CMakeLists.txt'
--- standalone-clients/CMakeLists.txt	2012-01-24 08:53:48 +0000
+++ standalone-clients/CMakeLists.txt	2012-02-06 11:00:29 +0000
@@ -47,10 +47,10 @@
                 ${UNITY_SRC}/BackgroundEffectHelper.h
                 ${UNITY_SRC}/BGHash.cpp
                 ${UNITY_SRC}/BGHash.h
-                ${UNITY_SRC}/DashSearchBar.cpp
-                ${UNITY_SRC}/DashSearchBar.h
-                ${UNITY_SRC}/DashSearchBarSpinner.cpp
-                ${UNITY_SRC}/DashSearchBarSpinner.h
+                ${UNITY_SRC}/SearchBar.cpp
+                ${UNITY_SRC}/SearchBar.h
+                ${UNITY_SRC}/SearchBarSpinner.cpp
+                ${UNITY_SRC}/SearchBarSpinner.h
                 ${UNITY_SRC}/DashView.cpp
                 ${UNITY_SRC}/DashView.h
                 ${UNITY_SRC}/DashViewPrivate.cpp
@@ -84,6 +84,10 @@
                 ${UNITY_SRC}/PlacesSimpleTile.h
                 ${UNITY_SRC}/PlacesVScrollBar.cpp
                 ${UNITY_SRC}/PlacesVScrollBar.h
+                ${UNITY_SRC}/DashView.cpp
+                ${UNITY_SRC}/DashView.h
+                ${UNITY_SRC}/DashViewPrivate.cpp
+                ${UNITY_SRC}/DashViewPrivate.h
                 ${UNITY_SRC}/DashStyle.cpp
                 ${UNITY_SRC}/IconLoader.cpp
                 ${UNITY_SRC}/IconLoader.h
@@ -456,6 +460,39 @@
                )
 add_dependencies (bg-hash unity-core-${UNITY_API_VERSION})
 
+add_executable (hud
+                StandaloneHud.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/DashSettings.cpp
+                ${UNITY_SRC}/DashSettings.h
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/HudButton.cpp
+                ${UNITY_SRC}/HudIcon.cpp
+                ${UNITY_SRC}/HudIcon.h
+                ${UNITY_SRC}/HudIconTextureSource.cpp
+                ${UNITY_SRC}/HudIconTextureSource.h
+                ${UNITY_SRC}/HudView.cpp
+                ${UNITY_SRC}/IMTextEntry.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/IconRenderer.cpp
+                ${UNITY_SRC}/IconTextureSource.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/OverlayRenderer.cpp
+                ${UNITY_SRC}/SearchBar.cpp
+                ${UNITY_SRC}/SearchBarSpinner.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/Timer.cpp
+                ${UNITY_SRC}/UBusWrapper.cpp
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/UScreen.cpp
+                ${UNITY_SRC}/UScreen.h
+               )
+add_dependencies (hud unity-core-${UNITY_API_VERSION})
+
 add_executable (test-shortcut
                 TestShortcut.cpp
                 ${UNITY_SRC}/AbstractSeparator.cpp

=== added file 'standalone-clients/StandaloneHud.cpp'
--- standalone-clients/StandaloneHud.cpp	1970-01-01 00:00:00 +0000
+++ standalone-clients/StandaloneHud.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,171 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY 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
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ *
+ */
+
+#include <sstream>
+#include "Nux/Nux.h"
+#include "Nux/VLayout.h"
+#include "Nux/Button.h"
+#include "Nux/TextureArea.h"
+#include "Nux/WindowThread.h"
+#include "NuxGraphics/GraphicsEngine.h"
+#include <gtk/gtk.h>
+
+#include "HudView.h"
+#include "DashStyle.h"
+#include "DashSettings.h"
+#include <NuxCore/Logger.h>
+
+namespace
+{
+  nux::logging::Logger logger("unity.tests.Hud");
+}
+
+class TestRunner
+{
+public:
+  TestRunner ();
+  ~TestRunner ();
+
+  static void InitWindowThread (nux::NThread* thread, void* InitData);
+  void Init ();
+  nux::Layout *layout;
+  unity::hud::View* hud_view_;
+  unity::dash::Settings dash_settings_;
+
+private:
+  unity::hud::Hud hud_service_;
+};
+
+TestRunner::TestRunner ()
+  : hud_service_("com.canonical.hud", "/com/canonical/hud")
+{
+}
+
+TestRunner::~TestRunner ()
+{
+}
+
+void TestRunner::Init ()
+{
+  LOG_WARNING(logger) << "test init";
+  layout = new nux::VLayout();
+
+  hud_view_ = new unity::hud::View();
+
+  layout->AddView (hud_view_, 1, nux::MINOR_POSITION_TOP, nux::MINOR_SIZE_FULL);
+  nux::GetWindowCompositor().SetKeyFocusArea(hud_view_->default_focus());
+
+  nux::GetWindowThread()->SetLayout (layout);
+
+  // things the controller normally does
+  hud_service_.queries_updated.connect([&] (unity::hud::Hud::Queries queries) {
+    hud_view_->SetQueries(queries);
+    std::string icon_name = "";
+    for (auto query = queries.begin(); query != queries.end(); query++)
+    {
+      if (!(*query)->icon_name.empty())
+      {
+        LOG_DEBUG(logger) << "Setting icon name to: " << (*query)->icon_name;
+        icon_name = (*query)->icon_name;
+        break;
+      }
+    }
+ 
+   hud_view_->SetIcon(icon_name);
+
+  });
+
+  hud_view_->query_activated.connect([&] (unity::hud::Query::Ptr query) {
+    hud_service_.ExecuteQuery(query, 0);
+  });  
+  
+  hud_view_->query_selected.connect([&] (unity::hud::Query::Ptr query) {
+    hud_view_->SetIcon(query->icon_name);
+  });
+
+  hud_view_->search_changed.connect([&] (std::string search_string) {
+    hud_service_.RequestQuery(search_string);
+  });
+
+  hud_view_->search_activated.connect([&] (std::string search_string) {
+    hud_service_.ExecuteQueryBySearch(search_string, 0);
+  });
+
+  hud_service_.RequestQuery("");
+ 
+  hud_view_->SetWindowGeometry(layout->GetAbsoluteGeometry(), layout->GetGeometry());
+
+}
+
+void TestRunner::InitWindowThread(nux::NThread* thread, void* InitData)
+{
+  TestRunner *self =  (TestRunner *) InitData;
+  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;
+
+  // no real tests right now, just make sure we don't get any criticals and such
+  // waiting on nice perceptual diff support before we can build real tests
+  // for views
+
+  g_type_init ();
+  gtk_init (&argc, &argv);
+
+  nux::NuxInitialize(0);
+  
+  // Slightly higher as we're more likely to test things we know will fail
+  nux::logging::configure_logging("unity.hud=debug");
+  
+  nux::logging::configure_logging(::getenv("UNITY_LOG_SEVERITY"));
+  LOG_DEBUG(logger) << "starting the standalone hud";
+  // The instances for the pseudo-singletons.
+  unity::dash::Style dash_style;
+
+  TestRunner *test_runner = new TestRunner ();
+  wt = nux::CreateGUIThread(TEXT("Hud Prototype Test"),
+                            1200, 768,
+                            0,
+                            &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-02-01 03:39:14 +0000
+++ tests/CMakeLists.txt	2012-02-06 11:00:29 +0000
@@ -99,6 +99,8 @@
 
 # The service that provides DBus services to test against
   add_executable(test-gtest-service
+                 test_service_hud.c
+                 test_service_hud.h
                  test_service_lens.c
                  test_service_lens.h
                  test_service_main.c
@@ -183,7 +185,8 @@
                  test_utils.h
                  test_ratings_filter.cpp
                  test_results.cpp
-                 )
+                 test_hud.cpp
+                )
   target_link_libraries(test-gtest-dbus ${GTEST_BOTH_LIBRARIES})
   add_test(UnityGTestDBus test-gtest-dbus)
   add_dependencies(test-gtest-dbus unity-core-${UNITY_API_VERSION} test-gtest-service)

=== added file 'tests/test_hud.cpp'
--- tests/test_hud.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_hud.cpp	2012-02-06 11:00:29 +0000
@@ -0,0 +1,104 @@
+#include <gtest/gtest.h>
+#include <glib-object.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Hud.h>
+
+using namespace std;
+
+namespace
+{
+
+GMainLoop* loop_ = NULL;
+unity::hud::Hud *hud;
+
+class TestHud : public ::testing::Test
+{
+public:
+  TestHud()
+    : query_return_result(false)
+    , connected_result(false)
+  {
+  }
+  unity::hud::Hud::Queries queries;
+  bool query_return_result;
+  bool connected_result;
+};
+
+TEST_F(TestHud, TestConstruction)
+{
+  loop_ = g_main_loop_new(NULL, FALSE);
+  hud = new unity::hud::Hud("com.canonical.Unity.Test", "/com/canonical/hud");
+  
+  // performs a check on the hud, if the hud is connected, report a sucess
+  auto timeout_check = [] (gpointer data) -> gboolean
+  {
+    TestHud* self = static_cast<TestHud*>(data);
+    if (hud->connected)
+    {
+      self->connected_result = true;
+      g_main_loop_quit(loop_);
+      return FALSE;
+    }
+    else
+    {
+      self->connected_result = false;
+      return TRUE;
+    }
+  };
+  
+
+  // if the hud is not connected when this lambda runs, fail.
+  auto timeout_bailout = [] (gpointer data) -> gboolean 
+  {
+    TestHud* self = static_cast<TestHud*>(data);
+    // reached timeout, failed testing
+    self->connected_result = false;
+    g_main_loop_quit(loop_);
+    return FALSE;
+  };
+  
+  g_timeout_add_seconds(1, timeout_check, this);
+  g_timeout_add_seconds(10, timeout_bailout, this);
+
+  g_main_loop_run(loop_);
+  
+  EXPECT_EQ(connected_result, true);
+}
+
+TEST_F(TestHud, TestQueryReturn)
+{
+  query_return_result = false;
+  
+  // make sure we receive the queries
+  auto query_connection = [this](unity::hud::Hud::Queries queries_) 
+  { 
+    query_return_result = true;
+    g_main_loop_quit(loop_);
+    queries = queries_;
+  };
+
+  auto timeout_bailout = [] (gpointer data) -> gboolean
+  {
+    TestHud* self = static_cast<TestHud*>(data);
+    self->query_return_result = false;
+    g_main_loop_quit(loop_);
+    return FALSE;
+  };
+   
+  hud->queries_updated.connect(query_connection);
+ 
+  guint source_id = g_timeout_add_seconds(10, timeout_bailout, this);
+ 
+  // next check we get 30 entries from this specific known callback
+  hud->RequestQuery("Request30Queries");
+  g_main_loop_run(loop_);
+  EXPECT_EQ(query_return_result, true);
+  EXPECT_NE(queries.size(), 0);
+  g_source_remove(source_id);
+
+  // finally close the connection - Nothing to check for here
+  hud->CloseQuery();
+}
+
+
+}

=== added file 'tests/test_service_hud.c'
--- tests/test_service_hud.c	1970-01-01 00:00:00 +0000
+++ tests/test_service_hud.c	2012-02-06 11:00:29 +0000
@@ -0,0 +1,268 @@
+#include "test_service_hud.h"
+#include <unity.h>
+#include <gio/gio.h>
+
+const char * hud_interface = 
+"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+"<node name=\"/\">\n"
+"        <interface name=\"com.canonical.hud\">\n"
+"<!-- Properties -->\n"
+"                <!-- None -->\n"
+"\n"
+"<!-- Functions -->\n"
+"                <method name=\"StartQuery\">\n"
+"                        <!-- in -->\n"
+"                        <arg type=\"s\" name=\"query\" direction=\"in\" />\n"
+"                        <arg type=\"i\" name=\"entries\" direction=\"in\" />\n"
+"                        <!-- out -->\n"
+"                        <arg type=\"s\" name=\"target\" direction=\"out\" />\n"
+"                        <arg type=\"a(sssssv)\" name=\"suggestions\" direction=\"out\" />\n"
+"                        <arg type=\"v\" name=\"querykey\" direction=\"out\" />\n"
+"                </method>\n"
+"\n"
+"                <method name=\"ExecuteQuery\">\n"
+"                        <arg type=\"v\" name=\"key\" direction=\"in\" />\n"
+"                        <arg type=\"u\" name=\"timestamp\" direction=\"in\" />\n"
+"                </method>\n"
+"\n"
+"                <method name=\"CloseQuery\">\n"
+"                        <arg type=\"v\" name=\"querykey\" direction=\"in\" />\n"
+"                </method>\n"
+"\n"
+"<!-- Signals -->\n"
+"                <signal name=\"UpdatedQuery\">\n"
+"                        <arg type=\"s\" name=\"target\" direction=\"out\" />\n"
+"                        <arg type=\"a(sssssv)\" name=\"suggestions\" direction=\"out\" />\n"
+"                        <arg type=\"v\" name=\"querykey\" direction=\"out\" />\n"
+"                </signal>\n"
+"\n"
+"<!-- End of interesting stuff -->\n"
+"\n"
+"        </interface>\n"
+"</node>\n"
+;
+static void bus_got_cb          (GObject *object, GAsyncResult * res, gpointer user_data);
+static void bus_method          (GDBusConnection *connection,
+                                const gchar *sender,
+                                const gchar *object_path,
+                                const gchar *interface_name,
+                                const gchar *method_name,
+                                GVariant *parameters,
+                                GDBusMethodInvocation *invocation,
+                                gpointer user_data);
+
+G_DEFINE_TYPE(ServiceHud, service_hud, G_TYPE_OBJECT);
+static GDBusNodeInfo * node_info = NULL;
+static GDBusInterfaceInfo * iface_info = NULL;
+static GDBusInterfaceVTable bus_vtable = {
+  method_call: bus_method,
+  get_property: NULL,
+  set_property: NULL,
+};
+
+
+struct _ServiceHudPrivate
+{
+  GDBusConnection * bus;
+  GCancellable * bus_lookup;
+  guint bus_registration;
+};
+
+static void
+service_hud_dispose(GObject* object)
+{
+  ServiceHud* self = SERVICE_HUD(object);
+  if (self->priv->bus_lookup != NULL) {
+    g_cancellable_cancel(self->priv->bus_lookup);
+    g_object_unref(self->priv->bus_lookup);
+    self->priv->bus_lookup = NULL;
+  }
+
+  if (self->priv->bus_registration != 0) {
+    g_dbus_connection_unregister_object(self->priv->bus, self->priv->bus_registration);
+    self->priv->bus_registration = 0;
+  }
+
+  if (self->priv->bus != NULL) {
+    g_object_unref(self->priv->bus);
+    self->priv->bus = NULL;
+  }
+
+}
+
+static void
+service_hud_class_init(ServiceHudClass* klass)
+{
+  G_OBJECT_CLASS(klass)->dispose = service_hud_dispose;
+  g_type_class_add_private (klass, sizeof (ServiceHudPrivate));
+
+  if (node_info == NULL) 
+  {
+    GError * error = NULL;
+
+    node_info = g_dbus_node_info_new_for_xml(hud_interface, &error);
+    if (error != NULL) 
+    {
+        g_error("Unable to parse HUD interface: %s", error->message);
+        g_error_free(error);
+    }
+  }
+
+  if (node_info != NULL && iface_info == NULL) 
+  {
+    iface_info = g_dbus_node_info_lookup_interface(node_info,"com.canonical.hud");
+    if (iface_info == NULL) 
+    {
+      g_error("Unable to find interface 'com.canonical.hud'");
+    }
+  }
+
+}
+
+static void
+service_hud_init(ServiceHud* self)
+{
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self, SERVICE_TYPE_HUD, ServiceHudPrivate);
+  self->priv->bus = NULL;
+  self->priv->bus_lookup = NULL;
+  self->priv->bus_registration = 0;
+  
+  self->priv->bus_lookup = g_cancellable_new();
+  g_bus_get(G_BUS_TYPE_SESSION, self->priv->bus_lookup, bus_got_cb, self);
+  
+}
+
+ServiceHud*
+service_hud_new()
+{
+  return g_object_new(SERVICE_TYPE_HUD, NULL);
+}
+
+static void
+bus_got_cb (GObject *object, GAsyncResult * res, gpointer user_data)
+{
+  GError * error = NULL;
+  ServiceHud * self = SERVICE_HUD(user_data);
+  GDBusConnection * bus;
+
+  bus = g_bus_get_finish(res, &error);
+  if (error != NULL) {
+    g_critical("Unable to get bus: %s", error->message);
+    g_error_free(error);
+    return;
+  }
+
+  self->priv->bus = bus;
+
+  /* Register object */
+  self->priv->bus_registration = g_dbus_connection_register_object(bus,
+                                                  /* path */       "/com/canonical/hud",
+                                                  /* interface */  iface_info,
+                                                  /* vtable */     &bus_vtable,
+                                                  /* userdata */   self,
+                                                  /* destroy */    NULL,
+                                                  /* error */      &error);
+
+  if (error != NULL) {
+    g_critical ("Unable to create bus connection object, %s", error->message);
+    g_error_free(error);
+    return;
+  }
+  
+  return;
+}
+
+static void
+bus_method (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data)
+{
+  if (g_strcmp0(method_name, "StartQuery") == 0) 
+  {
+    GVariant * ret = NULL;
+    gchar * query = NULL;
+    int num_entries = 0;
+
+    g_variant_get(parameters, "(si)", &query, &num_entries);
+
+    /* Build into into a variant */
+    GVariantBuilder ret_builder;
+    g_variant_builder_init(&ret_builder, G_VARIANT_TYPE_TUPLE);
+    g_variant_builder_add_value(&ret_builder, g_variant_new_string("target"));
+    GVariantBuilder builder;
+    
+    g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+     
+    int i = 0;
+    for (i = 0; i < num_entries; i++) 
+    {
+      gchar* target = g_strdup_printf("test-%i", i);
+      gchar* icon = g_strdup_printf("icon-%i", i);
+      gchar* future_icon = g_strdup(icon);
+      gchar* completion_text = g_strdup_printf("completion-%i", i);
+      gchar* accelerator = g_strdup_printf("<alt>+whatever");
+
+      GVariantBuilder tuple;
+      g_variant_builder_init(&tuple, G_VARIANT_TYPE_TUPLE);
+      g_variant_builder_add_value(&tuple, g_variant_new_string(target));
+      g_variant_builder_add_value(&tuple, g_variant_new_string(icon));
+      g_variant_builder_add_value(&tuple, g_variant_new_string(future_icon));
+      g_variant_builder_add_value(&tuple, g_variant_new_string(completion_text));
+      g_variant_builder_add_value(&tuple, g_variant_new_string(accelerator));
+      // build a fake key
+      GVariant* key;
+      {
+        GVariantBuilder keybuilder;
+        g_variant_builder_init(&keybuilder, G_VARIANT_TYPE_TUPLE);
+        g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+        g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+        g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+        g_variant_builder_add_value(&keybuilder, g_variant_new_int32(1986));
+
+        key = g_variant_new_variant(g_variant_builder_end(&keybuilder));
+      }
+      g_variant_ref_sink(key);
+      g_variant_builder_add_value(&tuple, key);
+      g_variant_builder_add_value(&builder, g_variant_builder_end(&tuple));
+      g_free(target);
+      g_free(icon);
+      g_free(future_icon);
+      g_free(completion_text);
+    }
+    g_variant_builder_add_value(&ret_builder, g_variant_builder_end(&builder));
+   
+    GVariant* query_key;
+    {
+      GVariantBuilder keybuilder;
+      g_variant_builder_init(&keybuilder, G_VARIANT_TYPE_TUPLE);
+      g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+      g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+      g_variant_builder_add_value(&keybuilder, g_variant_new_string("dummy string"));
+      g_variant_builder_add_value(&keybuilder, g_variant_new_int32(1986));
+
+      query_key = g_variant_new_variant(g_variant_builder_end(&keybuilder));
+    }
+    g_variant_ref_sink(query_key);
+    g_variant_builder_add_value(&ret_builder, query_key);
+    
+    ret = g_variant_builder_end(&ret_builder);
+
+    g_dbus_method_invocation_return_value(invocation, ret);
+    g_free(query);
+  } 
+  else if (g_strcmp0(method_name, "ExecuteQuery") == 0) 
+  {
+    GVariant * key = NULL;
+    key = g_variant_get_child_value(parameters, 0);
+    g_dbus_method_invocation_return_value(invocation, NULL);
+    g_variant_unref(key);
+  }
+  else if (g_strcmp0(method_name, "CloseQuery") == 0)
+  {
+    GVariant * key = NULL;
+    key = g_variant_get_child_value(parameters, 0);
+    g_dbus_method_invocation_return_value(invocation, NULL);
+    g_variant_unref(key);
+  }
+
+  return;
+}
+

=== added file 'tests/test_service_hud.h'
--- tests/test_service_hud.h	1970-01-01 00:00:00 +0000
+++ tests/test_service_hud.h	2012-02-06 11:00:29 +0000
@@ -0,0 +1,46 @@
+#ifndef _SERVICE_HUD_H_
+#define _SERVICE_HUD_H_
+
+#include <glib-object.h>
+G_BEGIN_DECLS
+
+#define SERVICE_TYPE_HUD (service_hud_get_type ())
+
+#define SERVICE_HUD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\
+  SERVICE_TYPE_HUD, ServiceHud))
+
+#define SERVICE_HUD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\
+  SERVICE_TYPE_HUD, ServiceHudClass))
+
+#define SERVICE_IS_HUD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\
+  SERVICE_TYPE_HUD))
+
+#define SERVICE_IS_HUD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\
+  SERVICE_TYPE_HUD))
+
+#define ServiceHud_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\
+  SERVICE_TYPE_HUD, ServiceHudClass))
+
+typedef struct _ServiceHud        ServiceHud;
+typedef struct _ServiceHudClass   ServiceHudClass;
+typedef struct _ServiceHudPrivate ServiceHudPrivate;
+
+struct _ServiceHud
+{
+  GObject parent;
+
+  ServiceHudPrivate *priv;
+};
+
+struct _ServiceHudClass
+{
+  GObjectClass parent_class;
+};
+
+GType service_hud_get_type(void) G_GNUC_CONST;
+
+ServiceHud* service_hud_new(void);
+
+G_END_DECLS
+
+#endif /* _SERVICE_HUD_H_ */

=== modified file 'tests/test_service_main.c'
--- tests/test_service_main.c	2011-07-26 09:08:42 +0000
+++ tests/test_service_main.c	2012-02-06 11:00:29 +0000
@@ -2,6 +2,7 @@
 
 #include "test_service_lens.h"
 #include "test_service_model.h"
+#include "test_service_hud.h"
 
 static void on_bus_aquired(GDBusConnection* conn, const gchar* name, gpointer null);
 static void handle_method_call(GDBusConnection       *connection,
@@ -34,6 +35,7 @@
 static GMainLoop* loop_ = NULL;
 static ServiceLens* lens_ = NULL;
 static ServiceModel* model_ = NULL;
+static ServiceHud* hud_ = NULL;
 
 gint
 main(gint argc, gchar** argv)
@@ -44,6 +46,7 @@
 
   lens_ = service_lens_new();
   model_ = service_model_new();
+  hud_ = service_hud_new();
 
   g_bus_own_name(G_BUS_TYPE_SESSION,
                  "com.canonical.Unity.Test",
@@ -57,8 +60,9 @@
   g_main_loop_run(loop_);
   g_main_loop_unref(loop_);
 
-  g_object_unref(lens_);
-  g_object_unref(model_);
+  //g_object_unref(lens_);
+  //g_object_unref(model_);
+  g_object_unref(hud_);
   g_dbus_node_info_unref(introspection_data);
 
   return 0;