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

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-12-19 22:18:53 +0000
+++ CMakeLists.txt	2012-01-25 11:34:37 +0000
@@ -8,7 +8,7 @@
 #
 set (PROJECT_NAME "unity")
 set (UNITY_MAJOR 5)
-set (UNITY_MINOR 0)
+set (UNITY_MINOR 1)
 set (UNITY_MICRO 0)
 set (UNITY_VERSION "${UNITY_MAJOR}.${UNITY_MINOR}.${UNITY_MICRO}")
 set (UNITY_API_VERSION "5.0")
@@ -110,7 +110,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-17 16:02:39 +0000
+++ UnityCore/CMakeLists.txt	2012-01-25 11:34:37 +0000
@@ -21,6 +21,7 @@
      GLibSignal-inl.h
      GLibWrapper.h
      GLibWrapper-inl.h
+     Hud.h
      IndicatorEntry.h
      Indicator.h
      Indicators.h
@@ -53,6 +54,7 @@
      GLibDBusProxy.cpp
      GLibSignal.cpp
      GLibWrapper.cpp
+     Hud.cpp
      Indicator.cpp
      IndicatorEntry.cpp
      Indicators.cpp

=== modified file 'UnityCore/GLibDBusProxy.cpp'
--- UnityCore/GLibDBusProxy.cpp	2012-01-16 15:19:47 +0000
+++ UnityCore/GLibDBusProxy.cpp	2012-01-25 11:34:37 +0000
@@ -144,7 +144,6 @@
   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-01-25 11:34:37 +0000
@@ -0,0 +1,239 @@
+// -*- 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)
+{
+  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)
+{
+  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)
+{
+  // as we are expecting an update, we want to check
+  // and make sure that we are the actual recievers 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(std::string(formatted_text), 
+                                            std::string(icon),
+                                            std::string(item_icon), 
+                                            std::string(completion_text),
+                                            std::string(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-01-25 11:34:37 +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-01-25 11:34:37 +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	2011-12-08 01:23:11 +0000
+++ plugins/unityshell/src/DashController.cpp	2012-01-25 11:34:37 +0000
@@ -242,7 +242,8 @@
 
   StartShowHideTimeline();
 
-  ubus_manager_.SendMessage(UBUS_PLACE_VIEW_SHOWN);
+  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "dash", TRUE);
+  ubus_manager_.SendMessage(UBUS_OVERLAY_SHOWN, info);
 }
 
 void Controller::HideDash(bool restore)
@@ -262,8 +263,9 @@
     PluginAdapter::Default ()->restoreInputFocus ();
 
   StartShowHideTimeline();
-
-  ubus_manager_.SendMessage(UBUS_PLACE_VIEW_HIDDEN);
+  
+  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "dash", TRUE);
+  ubus_manager_.SendMessage(UBUS_OVERLAY_HIDDEN, info);
 }
 
 void Controller::StartShowHideTimeline()

=== 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-01-25 11:34:37 +0000
@@ -1428,6 +1428,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);
 

=== 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-01-25 11:34:37 +0000
@@ -0,0 +1,182 @@
+/*
+ * 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_focused_(false)
+{
+  InitTheme();
+  OnKeyNavFocusChange.connect([this](nux::Area *area){ QueueDraw(); });
+}
+
+HudButton::HudButton (const std::string label_, NUX_FILE_LINE_DECL)
+    : nux::Button (NUX_FILE_LINE_PARAM)
+    , 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_focused_(false)
+{
+  InitTheme();
+}
+
+HudButton::HudButton (NUX_FILE_LINE_DECL)
+    : nux::Button (NUX_FILE_LINE_PARAM)
+    , is_focused_(false)
+{
+  InitTheme();
+}
+
+HudButton::~HudButton() {
+}
+
+void HudButton::InitTheme()
+{
+  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().Button(cr, faked_state, label_, dash::Alignment::LEFT);
+}
+
+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_REPEAT, nux::TEXWRAP_REPEAT);
+  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().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+  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,
+                      geo.width,
+                      geo.height,
+                      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_;
+}
+}
+}

=== 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-01-25 11:34:37 +0000
@@ -0,0 +1,76 @@
+/*
+ * 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>
+
+namespace unity {
+
+namespace hud {
+class HudButton : public nux::Button {
+  typedef nux::ObjectPtr<nux::BaseTexture> BaseTexturePtr;
+  typedef nux::ObjectPtr<HudButton> Ptr;
+public:
+  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;
+
+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);
+
+  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-01-25 11:34:37 +0000
@@ -0,0 +1,364 @@
+/*
+ * 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));
+
+  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() : ShowHud();
+}
+
+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();
+  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);
+  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);
+  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;
+    }
+  }
+  
+  view_->SetIcon(icon_name);
+}
+
+// Introspectable
+const gchar* Controller::GetName()
+{
+  return "unity.hud.Controller";
+}
+
+void Controller::AddProperties(GVariantBuilder* builder)
+{}
+
+
+}
+}

=== 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-01-25 11:34:37 +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:
+  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);
+
+protected:
+  const gchar* GetName();
+  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-01-25 11:34:37 +0000
@@ -0,0 +1,91 @@
+/*
+ * 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"
+
+//FIXME - we should be using the LauncherRenderer method of rendering icons here instead of compositing ourself
+// to make sure we get the correct average background colour and running indicator
+
+namespace unity
+{
+namespace hud
+{
+
+Icon::Icon(nux::BaseTexture* texture, guint width, guint height)
+  : unity::IconTexture(texture, width, height)
+{
+  Init();
+}
+
+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(54);
+  SetMinimumHeight(54);
+  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);
+}
+
+void Icon::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  nux::Geometry geo = GetGeometry();
+  // set up our texture mode
+  nux::TexCoordXForm texxform;
+  
+  GfxContext.QRP_1Tex(geo.x,
+                      geo.y,
+                      background_->GetWidth(),
+                      background_->GetHeight(),
+                      background_->GetDeviceTexture(),
+                      texxform,
+                      nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+  GfxContext.QRP_1Tex(geo.x,
+                      geo.y,
+                      gloss_->GetWidth(),
+                      gloss_->GetHeight(),
+                      gloss_->GetDeviceTexture(),
+                      texxform,
+                      nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+  GfxContext.QRP_1Tex(geo.x,
+                      geo.y,
+                      edge_->GetWidth(),
+                      edge_->GetHeight(),
+                      edge_->GetDeviceTexture(),
+                      texxform,
+                      nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+  unity::IconTexture::Draw(GfxContext, force_draw);
+}
+
+
+}
+}
+

=== 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-01-25 11:34:37 +0000
@@ -0,0 +1,69 @@
+// -*- 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 "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_;
+};
+
+}
+
+}
+
+#endif /* HUDICON_H */

=== added file 'plugins/unityshell/src/HudSearchBar.cpp'
--- plugins/unityshell/src/HudSearchBar.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudSearchBar.cpp	2012-01-25 11:34:37 +0000
@@ -0,0 +1,404 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2010-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 detais.
+ *
+ * You shoud 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]>
+ */
+
+/* FIXME!! - port this to the DashSearchBar and rename both to SearchBar */
+
+#include "config.h"
+
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+#include <Nux/HLayout.h>
+#include <Nux/Layout.h>
+#include <Nux/WindowCompositor.h>
+
+#include <NuxImage/CairoGraphics.h>
+#include <NuxImage/ImageSurface.h>
+#include <Nux/StaticText.h>
+
+#include <NuxGraphics/GLThread.h>
+#include <NuxGraphics/RenderingPipe.h>
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+
+#include "HudSearchBar.h"
+#include <UnityCore/Variant.h>
+
+#include "DashStyle.h"
+
+#define LIVE_SEARCH_TIMEOUT 250
+// Create a texture from the CairoGraphics object.
+//
+// Returns a new BaseTexture that has a ref count of 1.
+static nux::BaseTexture* texture_from_cairo_graphics(nux::CairoGraphics& cg)
+{
+  nux::NBitmapData* bitmap = cg.GetBitmap();
+  nux::BaseTexture* tex = nux::GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableTexture();
+  tex->Update(bitmap);
+  delete bitmap;
+  return tex;
+}
+
+namespace unity
+{
+namespace hud
+{
+
+NUX_IMPLEMENT_OBJECT_TYPE(SearchBar);
+
+SearchBar::SearchBar(NUX_FILE_LINE_DECL)
+  : View(NUX_FILE_LINE_PARAM)
+  , search_hint("")
+  , showing_filters(false)
+  , can_refine_search(false)
+  , live_search_timeout_(0)
+{
+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(10);
+  SetLayout(layout_);
+
+  spinner_ = new dash::SearchBarSpinner();
+  spinner_->SetMinMaxSize(icon->GetWidth(), icon->GetHeight());
+  spinner_->mouse_click.connect(sigc::mem_fun(this, &SearchBar::OnClearClicked));
+  layout_->AddView(spinner_, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+
+  hint_ = new nux::StaticCairoText(" ");
+  hint_->SetTextColor(nux::Color(1.0f, 1.0f, 1.0f, 0.5f));
+  hint_->SetMaximumWidth(570);
+
+  pango_entry_ = new dash::IMTextEntry();
+  pango_entry_->sigTextChanged.connect(sigc::mem_fun(this, &SearchBar::OnSearchChanged));
+  pango_entry_->activated.connect([&]() { activated.emit(); });
+  pango_entry_->cursor_moved.connect([&](int i) { QueueDraw(); });
+  pango_entry_->mouse_down.connect(sigc::mem_fun(this, &SearchBar::OnMouseButtonDown));
+  pango_entry_->end_key_focus.connect(sigc::mem_fun(this, &SearchBar::OnEndKeyFocus));
+  pango_entry_->SetMaximumWidth(570);
+
+  layered_layout_ = new nux::LayeredLayout();
+  layered_layout_->AddLayer(hint_);
+  layered_layout_->AddLayer(pango_entry_);
+  layered_layout_->SetPaintAll(true);
+  layered_layout_->SetActiveLayerN(1);
+  layered_layout_->SetMinimumWidth(420);
+  layered_layout_->SetMaximumWidth(645);
+  layout_->AddView(layered_layout_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
+
+  std::string filter_str = _("Filter results");
+  filter_str+= "  ▸";
+  show_filters_ = new nux::StaticCairoText(filter_str.c_str());
+  show_filters_->SetVisible(false);
+  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::Layout *filter_layout = new nux::HLayout();
+  filter_layout->SetHorizontalExternalMargin(12);
+  filter_layout->AddLayout(new nux::SpaceLayout(0, 10000, 0, 1), 1);
+  filter_layout->AddView(show_filters_, 0, nux::MINOR_POSITION_RIGHT);
+
+  layout_->AddView(filter_layout, 1, nux::MINOR_POSITION_RIGHT, nux::MINOR_SIZE_FIX);
+
+  sig_manager_.Add(new Signal<void, GtkSettings*, GParamSpec*>
+      (gtk_settings_get_default(),
+       "notify::gtk-font-name",
+       sigc::mem_fun(this, &SearchBar::OnFontChanged)));
+  OnFontChanged(gtk_settings_get_default());
+
+  search_hint.changed.connect([&](std::string const& s) { OnSearchHintChanged(); });
+  search_string.SetGetterFunction(sigc::mem_fun(this, &SearchBar::get_search_string));
+  search_string.SetSetterFunction(sigc::mem_fun(this, &SearchBar::set_search_string));
+  im_active.SetGetterFunction(sigc::mem_fun(this, &SearchBar::get_im_active));
+  showing_filters.changed.connect(sigc::mem_fun(this, &SearchBar::OnShowingFiltersChanged));
+  can_refine_search.changed.connect([&] (bool can_refine) { show_filters_->SetVisible(can_refine); });
+}
+
+SearchBar::~SearchBar()
+{
+  delete bg_layer_;
+
+  if (live_search_timeout_)
+    g_source_remove(live_search_timeout_);
+}
+
+void SearchBar::OnFontChanged(GtkSettings* settings, GParamSpec* pspec)
+{
+  static const int HOW_LARGE = 8;
+  gchar* font_name = NULL;
+  PangoFontDescription* desc;
+  gint size;
+  gchar* font_desc;
+
+  g_object_get(settings, "gtk-font-name", &font_name, NULL);
+
+  desc = pango_font_description_from_string(font_name);
+  pango_entry_->SetFontFamily(pango_font_description_get_family(desc));
+
+  size = pango_font_description_get_size(desc);
+  size /= pango_font_description_get_size_is_absolute(desc) ? 1 : PANGO_SCALE;
+  pango_entry_->SetFontSize(size + HOW_LARGE);
+
+  pango_entry_->SetFontOptions(gdk_screen_get_font_options(gdk_screen_get_default()));
+
+  font_desc = g_strdup_printf("%s %d", pango_font_description_get_family(desc), size + HOW_LARGE);
+  hint_->SetFont(font_desc);
+
+  g_free(font_desc);
+  font_desc = g_strdup_printf("%s %d", pango_font_description_get_family(desc), size + HOW_LARGE/2);
+  show_filters_->SetFont(font_desc);
+
+  pango_font_description_free(desc);
+  g_free(font_name);
+  g_free(font_desc);
+}
+
+void SearchBar::OnSearchHintChanged()
+{
+  std::string hint = search_hint;
+  gchar* tmp = g_markup_escape_text(hint.c_str(), -1);
+
+  gchar* markup  = g_strdup_printf("%s", tmp);
+  hint_->SetText(markup);
+
+  g_free(markup);
+  g_free(tmp);
+}
+
+void SearchBar::OnSearchChanged(nux::TextEntry* text_entry)
+{
+  // We don't want to set a new search string on every new character, so we add a sma
+  // timeout to see if the user is typing a sentence. If more characters are added, we
+  // keep restarting the timeout unti the user has actuay paused.
+  if (live_search_timeout_)
+    g_source_remove(live_search_timeout_);
+
+  live_search_timeout_ = g_timeout_add(LIVE_SEARCH_TIMEOUT,
+                                       (GSourceFunc)&OnLiveSearchTimeout,
+                                       this);
+
+  //spinner_->SetState(is_empty ? unity::dash::STATE_READY : unity::dash::STATE_SEARCHING);
+
+  pango_entry_->QueueDraw();
+  hint_->QueueDraw();
+  QueueDraw();
+
+  search_changed.emit(pango_entry_->GetText());
+}
+
+gboolean SearchBar::OnLiveSearchTimeout(SearchBar* sef)
+{
+  sef->live_search_reached.emit(sef->pango_entry_->GetText());
+  sef->live_search_timeout_ = 0;
+  return FALSE;
+}
+
+void SearchBar::OnShowingFiltersChanged(bool is_showing)
+{
+  std::string filter_str = _("Filter results");
+  filter_str += "  <small>";
+  filter_str += is_showing ? "▾" : "▸";
+  filter_str += "</small>";
+  show_filters_->SetText(filter_str.c_str());
+}
+
+void SearchBar::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  nux::Geometry geo = GetGeometry();
+
+  UpdateBackground();
+  GfxContext.PushClippingRectangle(geo);
+
+  nux::GetPainter().PaintBackground(GfxContext, geo);
+
+  bg_layer_->SetGeometry(nux::Geometry(geo.x, geo.y, last_width_, geo.height));
+  nux::GetPainter().RenderSinglePaintLayer(GfxContext,
+                                           bg_layer_->GetGeometry(),
+                                           bg_layer_);
+
+  GfxContext.PopClippingRectangle();    
+}
+
+void SearchBar::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  nux::Geometry geo = GetGeometry();
+
+  GfxContext.PushClippingRectangle(geo);
+
+  if (!IsFullRedraw())
+    gPainter.PushLayer(GfxContext, bg_layer_->GetGeometry(), bg_layer_);
+
+  layout_->ProcessDraw(GfxContext, force_draw);
+
+  if (!IsFullRedraw())
+    gPainter.PopBackground();
+  GfxContext.PopClippingRectangle();
+}
+
+void SearchBar::OnClearClicked(int x, int y, unsigned long button_fags,
+                                     unsigned long key_fags)
+{
+  pango_entry_->SetText("");
+  spinner_->SetState(unity::dash::STATE_READY);
+  live_search_reached.emit("");
+}
+
+void SearchBar::OnEntryActivated()
+{
+  activated.emit();
+}
+
+void
+SearchBar::SearchFinished()
+{
+  spinner_->SetState(unity::dash::STATE_CLEAR);
+}
+
+void SearchBar::UpdateBackground()
+{
+#define PADDING 12
+#define 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_)
+    return;
+
+  last_width_ = geo.width;
+  last_height_ = geo.height;
+
+  x = y = PADDING;
+  width = last_width_ - (2 * PADDING);
+  height = last_height_ - (2 * PADDING);
+
+  nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, last_width_, last_height_);
+  cairo_t* cr = cairo_graphics.GetContext();
+
+  cairo_graphics.DrawRoundedRectangle(cr,
+                                      1.0f,
+                                      x,
+                                      y,
+                                      RADIUS,
+                                      width,
+                                      height,
+                                      true);
+
+  cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width(cr, 1.0);
+  cairo_stroke_preserve(cr);
+  cairo_graphics.BlurSurface (3, cairo_get_target (cr));
+
+  cairo_operator_t op = CAIRO_OPERATOR_OVER;
+  op = cairo_get_operator (cr);
+  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+  cairo_set_source_rgba(cr, 0.0f, 0.0f, 0.0f, 0.5f);
+  cairo_fill_preserve(cr);
+  cairo_set_operator (cr, op);
+  cairo_set_source_rgba(cr, 0.0f, 0.0f, 0.0f, 0.5f);
+  cairo_fill_preserve(cr);
+  cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 0.8f);
+  //cairo_set_line_width(cr, 1.0);
+  cairo_stroke(cr);
+
+  cairo_destroy(cr);
+  nux::BaseTexture* texture2D = texture_from_cairo_graphics(cairo_graphics);
+
+  nux::TexCoordXForm texxform;
+  texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+  if (bg_layer_)
+    delete bg_layer_;
+
+  nux::ROPConfig rop;
+  rop.Blend = true;
+  rop.SrcBlend = GL_ONE;
+  rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+  bg_layer_ = new nux::TextureLayer(texture2D->GetDeviceTexture(),
+                                    texxform,
+                                    nux::color::White,
+                                    true,
+                                    rop);
+
+  texture2D->UnReference();
+}
+
+void SearchBar::OnMouseButtonDown(int x, int y, unsigned long button, unsigned long key)
+{
+  search_hint = "";
+}
+
+void SearchBar::OnEndKeyFocus()
+{
+  //search_hint = _("Search");
+}
+
+nux::TextEntry* SearchBar::text_entry() const
+{
+  return pango_entry_;
+}
+
+std::string SearchBar::get_search_string() const
+{
+  return pango_entry_->GetText();
+}
+
+bool SearchBar::set_search_string(std::string const& string)
+{
+  pango_entry_->SetText(string.c_str());
+  spinner_->SetState(string == "" ? unity::dash::STATE_READY : unity::dash::STATE_CLEAR);
+  return true;
+}
+
+bool SearchBar::get_im_active() const
+{
+  return pango_entry_->im_active();
+}
+
+//
+// Key navigation
+//
+bool
+SearchBar::AcceptKeyNavFocus()
+{
+  return false;
+}
+
+const gchar* SearchBar::GetName()
+{
+  return "SearchBar";
+}
+
+const gchar* SearchBar::GetChildsName()
+{
+  return "";
+}
+
+void SearchBar::AddProperties(GVariantBuilder* builder)
+{
+  unity::variant::BuilderWrapper(builder).add(GetGeometry());
+}
+
+}
+}

=== added file 'plugins/unityshell/src/HudSearchBar.h'
--- plugins/unityshell/src/HudSearchBar.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/HudSearchBar.h	2012-01-25 11:34:37 +0000
@@ -0,0 +1,116 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ */
+
+#ifndef HUD_SEARCH_BAR_H
+#define HUD_SEARCH_BAR_H
+
+#include <gtk/gtk.h>
+
+#include <NuxCore/Property.h>
+#include <Nux/LayeredLayout.h>
+#include <Nux/TextureArea.h>
+#include <Nux/View.h>
+#include <Nux/TextureArea.h>
+#include <NuxGraphics/GraphicsEngine.h>
+#include <Nux/EditTextBox.h>
+#include <Nux/TextEntry.h>
+#include <UnityCore/GLibSignal.h>
+
+#include "DashSearchBarSpinner.h"
+#include "IMTextEntry.h"
+#include "StaticCairoText.h"
+
+namespace unity
+{
+namespace hud
+{
+
+using namespace unity::glib;
+
+class SearchBar : public nux::View
+{
+  NUX_DECLARE_OBJECT_TYPE(SearchBar, nux::View);
+  typedef nux::ObjectPtr<SearchBar> Ptr;
+public:
+  SearchBar(NUX_FILE_LINE_PROTO);
+  ~SearchBar();
+
+  void SearchFinished();
+  nux::TextEntry* text_entry() const;
+
+  nux::RWProperty<std::string> search_string;
+  nux::Property<std::string> search_hint;
+  nux::Property<bool> showing_filters;
+  nux::Property<bool> can_refine_search;
+  nux::ROProperty<bool> im_active;
+
+  sigc::signal<void> activated;
+  sigc::signal<void, std::string const&> search_changed;
+  sigc::signal<void, std::string const&> live_search_reached;
+
+private:
+
+  void OnFontChanged(GtkSettings* settings, GParamSpec* pspec=NULL);
+  void OnSearchHintChanged();
+
+  void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
+
+  void OnMouseButtonDown(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnEndKeyFocus();
+
+  void UpdateBackground();
+  void OnSearchChanged(nux::TextEntry* text_entry);
+  void OnClearClicked(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnEntryActivated();
+  void OnShowingFiltersChanged(bool is_showing);
+
+  std::string get_search_string() const;
+  bool set_search_string(std::string const& string);
+  bool get_im_active() const;
+
+  static gboolean OnLiveSearchTimeout(SearchBar* self);
+
+  const gchar* GetName();
+  const gchar* GetChildsName();
+  void AddProperties(GVariantBuilder* builder);
+  bool AcceptKeyNavFocus();
+
+private:
+  glib::SignalManager sig_manager_;
+
+  nux::AbstractPaintLayer* bg_layer_;
+  nux::HLayout* layout_;
+  nux::LayeredLayout* layered_layout_;
+  nux::StaticCairoText* hint_;
+  unity::dash::IMTextEntry* pango_entry_;
+  nux::StaticCairoText* show_filters_;
+
+  int last_width_;
+  int last_height_;
+
+  guint live_search_timeout_;
+
+  unity::dash::SearchBarSpinner* spinner_;
+};
+
+}
+}
+
+#endif

=== 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-01-25 11:34:37 +0000
@@ -0,0 +1,377 @@
+/*
+ * 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()
+{
+}
+
+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)
+{
+  queries_ = queries_;
+  button_views_->Clear();
+  int found_items = 0;
+  for (auto query = queries.begin(); query != queries.end(); query++)
+  {
+    if (found_items > 5)
+      break;
+
+    HudButton *button = new HudButton();
+    button->SetQuery(*query);
+    button_views_->AddView(button, 0, nux::MINOR_POSITION_LEFT);
+
+    button->click.connect([&](nux::View* view) {
+      query_activated.emit(dynamic_cast<HudButton*>(view)->GetQuery());
+    });
+    
+    button->OnKeyNavFocusActivate.connect([&](nux::Area *area) {
+      query_activated.emit(dynamic_cast<HudButton*>(area)->GetQuery());
+    });
+
+    button->OnKeyNavFocusChange.connect([&](nux::Area *area){
+      query_selected.emit(dynamic_cast<HudButton*>(area)->GetQuery());
+    });
+    
+    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)
+{
+  dash::Style& style = dash::Style::Instance();
+  int width = 0, height = 0;
+  int tile_width = style.GetTileWidth();
+  int half = for_geo.width / 2;
+
+  while ((width += tile_width) + (19 * 2) < half)
+    ;
+
+  width = MAX(width, tile_width * 6);
+
+  width += 19 + 32;
+
+  height = search_bar_->GetGeometry().height;
+  height += 6;
+  height += (style.GetTextLineHeight() + (12*2)) * 6;
+  height += 6;
+
+  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;
+}
+
+void View::SetupViews()
+{
+  layout_ = new nux::HLayout();
+  layout_->AddLayout(new nux::SpaceLayout(8,8,8,8), 0);
+  
+  icon_ = new Icon("", icon_size, true);
+  //icon_->SetBaseSize(icon_size, icon_size);
+  //icon_->SetMinMaxSize(icon_size, icon_size);
+  
+  nux::Layout* icon_layout = new nux::VLayout();
+  icon_layout->SetVerticalExternalMargin(12);
+  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);
+
+  
+  content_layout_ = new nux::VLayout();
+  layout_->AddLayout(content_layout_.GetPointer(), 1, nux::MINOR_POSITION_TOP);
+  SetLayout(layout_.GetPointer());
+
+  // add the search bar to the composite
+  search_bar_ = new unity::hud::SearchBar();
+  search_bar_->search_hint = default_text;
+  search_bar_->search_changed.connect(sigc::mem_fun(this, &View::OnSearchChanged));
+  content_layout_->AddView(search_bar_.GetPointer(), 0, nux::MINOR_POSITION_LEFT);
+  
+  button_views_ = new nux::VLayout();
+  button_views_->SetHorizontalExternalMargin(12);
+  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_);
+}
+
+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
+const gchar* View::GetName()
+{
+  return "unity.hud.View";
+}
+
+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-01-25 11:34:37 +0000
@@ -0,0 +1,115 @@
+/*
+ * 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 "UBusWrapper.h"
+#include "HudIcon.h"
+#include "HudSearchBar.h"
+#include "OverlayRenderer.h"
+
+namespace unity
+{
+namespace hud
+{
+
+class View : public nux::View
+{
+  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);
+
+  const gchar* GetName();
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  UBusManager ubus;
+  nux::ObjectPtr<nux::Layout> layout_;
+  nux::ObjectPtr<nux::Layout> content_layout_;
+  nux::ObjectPtr<nux::VLayout> button_views_;
+  
+  //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/IconTexture.cpp'
--- plugins/unityshell/src/IconTexture.cpp	2011-11-08 18:21:44 +0000
+++ plugins/unityshell/src/IconTexture.cpp	2012-01-25 11:34:37 +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();
 }
 
@@ -78,25 +80,33 @@
 
 void IconTexture::SetByIconName(const char* icon_name, unsigned int size)
 {
-  g_free(_icon_name);
-  _icon_name = g_strdup(icon_name);
-  _size = size;
-  LoadIcon();
+  if (g_strcmp0(icon_name, "") != 0)
+  {
+    g_free(_icon_name);
+    _icon_name = g_strdup(icon_name);
+    _size = size;
+    LoadIcon();
+  }
 }
 
 void IconTexture::SetByFilePath(const char* file_path, unsigned int size)
 {
-  g_free(_icon_name);
-  _icon_name = g_strdup(file_path);
-  _size = size;
+  if (g_strcmp0(file_path, "") != 0)
+  {
+    g_free(_icon_name);
+    _icon_name = g_strdup(file_path);
+    _size = size;
 
-  LoadIcon();
+    LoadIcon();
+  }
 }
 
 void IconTexture::LoadIcon()
 {
   static const char* const DEFAULT_GICON = ". GThemedIcon text-x-preview";
-
+  if (_icon_name == NULL)
+    return;
+ 
   if (_loading)
     return;
   _loading = true;
@@ -144,6 +154,7 @@
                                       _texture_height,
                                       sigc::mem_fun(this, &IconTexture::CreateTextureCallback));
   QueueDraw();
+  _loading = false;
 }
 
 void IconTexture::IconLoaded(std::string const& icon_name, unsigned size,
@@ -162,6 +173,8 @@
     if (icon_name != DEFAULT_ICON)
       SetByIconName(DEFAULT_ICON, _size);
   }
+
+  QueueDraw();
 }
 
 void IconTexture::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)

=== modified file 'plugins/unityshell/src/Launcher.cpp'
--- plugins/unityshell/src/Launcher.cpp	2012-01-23 13:07:40 +0000
+++ plugins/unityshell/src/Launcher.cpp	2012-01-25 11:34:37 +0000
@@ -282,8 +282,8 @@
   _drag_window = NULL;
   _offscreen_drag_texture = nux::GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(2, 2, 1, nux::BITFMT_R8G8B8A8);
 
-  ubus.RegisterInterest(UBUS_PLACE_VIEW_SHOWN, sigc::mem_fun(this, &Launcher::OnPlaceViewShown));
-  ubus.RegisterInterest(UBUS_PLACE_VIEW_HIDDEN, sigc::mem_fun(this, &Launcher::OnPlaceViewHidden));
+  ubus.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &Launcher::OnOverlayShown));
+  ubus.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &Launcher::OnOverlayHidden));
   ubus.RegisterInterest(UBUS_LAUNCHER_ACTION_DONE, sigc::mem_fun(this, &Launcher::OnActionDone));
   ubus.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, sigc::mem_fun(this, &Launcher::OnBGColorChanged));
   ubus.RegisterInterest(UBUS_LAUNCHER_LOCK_HIDE, sigc::mem_fun(this, &Launcher::OnLockHideChanged));
@@ -1490,34 +1490,52 @@
   }
 }
 
-void Launcher::OnPlaceViewShown(GVariant* data)
+void Launcher::OnOverlayShown(GVariant* data)
 {
-  LauncherModel::iterator it;
-
-  _dash_is_open = true;
-  bg_effect_helper_.enabled = true;
-  _hide_machine->SetQuirk(LauncherHideMachine::PLACES_VISIBLE, true);
-  _hover_machine->SetQuirk(LauncherHoverMachine::PLACES_VISIBLE, true);
-
-  DesaturateIcons();
+  // check the type of overlay
+  gchar* overlay_identity = NULL;
+  gboolean can_maximise = FALSE;
+  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING, 
+                &overlay_identity, &can_maximise);
+
+  if (!g_strcmp0(overlay_identity, "dash"))
+  {
+    LauncherModel::iterator it;
+
+    _dash_is_open = true;
+    bg_effect_helper_.enabled = true;
+    _hide_machine->SetQuirk(LauncherHideMachine::PLACES_VISIBLE, true);
+    _hover_machine->SetQuirk(LauncherHoverMachine::PLACES_VISIBLE, true);
+
+    DesaturateIcons();
+  }
 }
 
-void Launcher::OnPlaceViewHidden(GVariant* data)
+void Launcher::OnOverlayHidden(GVariant* data)
 {
-  LauncherModel::iterator it;
-
-  _dash_is_open = false;
-  bg_effect_helper_.enabled = false;
-  _hide_machine->SetQuirk(LauncherHideMachine::PLACES_VISIBLE, false);
-  _hover_machine->SetQuirk(LauncherHoverMachine::PLACES_VISIBLE, false);
-
-  // as the leave event is no more received when the place is opened
-  // FIXME: remove when we change the mouse grab strategy in nux
-  nux::Point pt = nux::GetWindowCompositor().GetMousePosition();
-
-  SetStateMouseOverLauncher(GetAbsoluteGeometry().IsInside(pt));
-
-  SaturateIcons();
+  // check the type of overlay
+  gchar* overlay_identity = NULL;
+  gboolean can_maximise = FALSE;
+  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING, 
+                &overlay_identity, &can_maximise);
+
+  if (!g_strcmp0(overlay_identity, "dash"))
+  {
+    LauncherModel::iterator it;
+
+    _dash_is_open = false;
+    bg_effect_helper_.enabled = false;
+    _hide_machine->SetQuirk(LauncherHideMachine::PLACES_VISIBLE, false);
+    _hover_machine->SetQuirk(LauncherHoverMachine::PLACES_VISIBLE, false);
+
+    // as the leave event is no more received when the place is opened
+    // FIXME: remove when we change the mouse grab strategy in nux
+    nux::Point pt = nux::GetWindowCompositor().GetMousePosition();
+
+    SetStateMouseOverLauncher(GetAbsoluteGeometry().IsInside(pt));
+
+    SaturateIcons();
+  }
 }
 
 void Launcher::OnActionDone(GVariant* data)

=== modified file 'plugins/unityshell/src/Launcher.h'
--- plugins/unityshell/src/Launcher.h	2012-01-23 13:07:40 +0000
+++ plugins/unityshell/src/Launcher.h	2012-01-25 11:34:37 +0000
@@ -350,8 +350,8 @@
 
   void OnIconNeedsRedraw(AbstractLauncherIcon* icon);
 
-  void OnPlaceViewHidden(GVariant* data);
-  void OnPlaceViewShown(GVariant* data);
+  void OnOverlayHidden(GVariant* data);
+  void OnOverlayShown(GVariant* data);
 
   void DesaturateIcons();
   void SaturateIcons();

=== modified file 'plugins/unityshell/src/PanelMenuView.cpp'
--- plugins/unityshell/src/PanelMenuView.cpp	2012-01-12 13:36:44 +0000
+++ plugins/unityshell/src/PanelMenuView.cpp	2012-01-25 11:34:37 +0000
@@ -155,10 +155,10 @@
 
   // Register for all the interesting events
   UBusServer* ubus = ubus_server_get_default();
-  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_PLACE_VIEW_SHOWN,
+  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_OVERLAY_SHOWN,
                                                           (UBusCallback)PanelMenuView::OnPlaceViewShown,
                                                           this));
-  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_PLACE_VIEW_HIDDEN,
+  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_OVERLAY_HIDDEN,
                                                           (UBusCallback)PanelMenuView::OnPlaceViewHidden,
                                                           this));
 

=== modified file 'plugins/unityshell/src/PanelView.cpp'
--- plugins/unityshell/src/PanelView.cpp	2012-01-16 07:34:25 +0000
+++ plugins/unityshell/src/PanelView.cpp	2012-01-25 11:34:37 +0000
@@ -103,11 +103,11 @@
                                                           (UBusCallback)&PanelView::OnBackgroundUpdate,
                                                           this);
 
-   _handle_dash_hidden = ubus_server_register_interest(ubus, UBUS_PLACE_VIEW_HIDDEN,
+   _handle_dash_hidden = ubus_server_register_interest(ubus, UBUS_OVERLAY_HIDDEN,
                                                       (UBusCallback)&PanelView::OnDashHidden,
                                                       this);
 
-   _handle_dash_shown = ubus_server_register_interest(ubus, UBUS_PLACE_VIEW_SHOWN,
+   _handle_dash_shown = ubus_server_register_interest(ubus, UBUS_OVERLAY_SHOWN,
                                                      (UBusCallback)&PanelView::OnDashShown,
                                                      this);
    // request the latest colour from bghash

=== modified file 'plugins/unityshell/src/PlacesHomeView.cpp'
--- plugins/unityshell/src/PlacesHomeView.cpp	2011-12-14 20:04:23 +0000
+++ plugins/unityshell/src/PlacesHomeView.cpp	2012-01-25 11:34:37 +0000
@@ -106,7 +106,7 @@
                          (style.GetHomeTileHeight() * 2) + 32);
 
   _ubus_handle = ubus_server_register_interest(ubus_server_get_default(),
-                                               UBUS_PLACE_VIEW_SHOWN,
+                                               UBUS_OVERLAY_SHOWN,
                                                (UBusCallback) &PlacesHomeView::DashVisible,
                                                this);
 

=== modified file 'plugins/unityshell/src/UBusMessages.h'
--- plugins/unityshell/src/UBusMessages.h	2012-01-17 15:41:30 +0000
+++ plugins/unityshell/src/UBusMessages.h	2012-01-25 11:34:37 +0000
@@ -34,9 +34,11 @@
 #define UBUS_PLACE_ENTRY_ACTIVATE_REQUEST "PLACE_ENTRY_ACTIVATE_REQUEST"
 #define UBUS_DASH_ABOUT_TO_SHOW "DASH_ABOUT_TO_SHOW"
 
-// Signal send when places are shown or hidden
-#define UBUS_PLACE_VIEW_HIDDEN "PLACE_VIEW_HIDDEN"
-#define UBUS_PLACE_VIEW_SHOWN "PLACE_VIEW_SHOWN"
+// Signal sent when an overlay interface is shown, includes a gvariant
+// gvariant format is (sb), (interface-name, can_maximize?) 
+#define UBUS_OVERLAY_FORMAT_STRING "(sb)"
+#define UBUS_OVERLAY_HIDDEN "OVERLAY_HIDDEN"
+#define UBUS_OVERLAY_SHOWN "OVERLAY_SHOWN"
 
 #define UBUS_PLACE_VIEW_QUEUE_DRAW "PLACE_VIEW_QUEUE_DRAW"
 
@@ -76,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/WindowButtons.cpp'
--- plugins/unityshell/src/WindowButtons.cpp	2011-12-14 20:04:23 +0000
+++ plugins/unityshell/src/WindowButtons.cpp	2012-01-25 11:34:37 +0000
@@ -54,7 +54,7 @@
       _normal_dash_tex(NULL),
       _prelight_dash_tex(NULL),
       _pressed_dash_tex(NULL),
-      _dash_is_open(false),
+      _overlay_is_open(false),
       _mouse_is_down(false),
       _place_shown_interest(0),
       _place_hidden_interest(0),
@@ -66,11 +66,11 @@
     dash::Settings::Instance().changed.connect(sigc::mem_fun(this, &WindowButton::UpdateDashUnmaximize));
 
     UBusServer* ubus = ubus_server_get_default();
-    _place_shown_interest = ubus_server_register_interest(ubus, UBUS_PLACE_VIEW_SHOWN,
-                                                          (UBusCallback)&WindowButton::OnPlaceViewShown,
+    _place_shown_interest = ubus_server_register_interest(ubus, UBUS_OVERLAY_SHOWN,
+                                                          (UBusCallback)&WindowButton::OnOverlayShown,
                                                           this);
-    _place_hidden_interest = ubus_server_register_interest(ubus, UBUS_PLACE_VIEW_HIDDEN,
-                                                           (UBusCallback)&WindowButton::OnPlaceViewHidden,
+    _place_hidden_interest = ubus_server_register_interest(ubus, UBUS_OVERLAY_HIDDEN,
+                                                           (UBusCallback)&WindowButton::OnOverlayHidden,
                                                            this);
 
     /* FIXME HasMouseFocus() doesn't seem to work correctly, so we use this workaround */
@@ -106,7 +106,7 @@
 
     GfxContext.PushClippingRectangle(geo);
 
-    if (_dash_is_open)
+    if (_overlay_is_open)
     {
       //FIXME should use HasMouseFocus()
       if (_mouse_is_down && IsMouseInside())
@@ -163,7 +163,7 @@
     _prelight_dash_tex = GetDashWindowButton(_type, panel::WindowState::PRELIGHT);
     _pressed_dash_tex = GetDashWindowButton(_type, panel::WindowState::PRESSED);
 
-    if (_dash_is_open)
+    if (_overlay_is_open)
     {
       if (_normal_dash_tex)
         SetMinMaxSize(_normal_dash_tex->GetWidth(), _normal_dash_tex->GetHeight());
@@ -190,6 +190,7 @@
     if (_pressed_dash_tex)
       _pressed_dash_tex->UnReference();
 
+    //!!FIXME!! - don't have disabled instances of the (un)maximize buttons
     if (dash::Settings::Instance().GetFormFactor() == dash::FormFactor::DESKTOP)
     {
       // get maximize buttons
@@ -208,7 +209,7 @@
     // still check if the dash is really opened,
     // someone could change the form factor through dconf
     // when the dash is closed
-    if (_dash_is_open)
+    if (_overlay_is_open)
     {
       if (_normal_dash_tex)
         SetMinMaxSize(_normal_dash_tex->GetWidth(), _normal_dash_tex->GetHeight());
@@ -239,28 +240,35 @@
   nux::BaseTexture* _normal_dash_tex;
   nux::BaseTexture* _prelight_dash_tex;
   nux::BaseTexture* _pressed_dash_tex;
-  bool _dash_is_open;
+  bool _overlay_is_open;
+  bool _overlay_can_maximize;
   bool _mouse_is_down;
   guint32 _place_shown_interest;
   guint32 _place_hidden_interest;
   double _opacity;
 
-  static void OnPlaceViewShown(GVariant* data, void* val)
+  static void OnOverlayShown(GVariant* data, void* val)
   {
+    gchar* overlay_identity = NULL;
+    gboolean can_maximise = FALSE;
+    g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING, 
+                  &overlay_identity, &can_maximise);
     WindowButton* self = (WindowButton*)val;
 
-    self->_dash_is_open = true;
+    self->_overlay_is_open = true;
     if (self->_normal_dash_tex)
       self->SetMinMaxSize(self->_normal_dash_tex->GetWidth(), self->_normal_dash_tex->GetHeight());
 
+    self->_overlay_can_maximize = (can_maximise) ? true : false;
+
     self->QueueDraw();
   }
 
-  static void OnPlaceViewHidden(GVariant* data, void* val)
+  static void OnOverlayHidden(GVariant* data, void* val)
   {
     WindowButton* self = (WindowButton*)val;
 
-    self->_dash_is_open = false;
+    self->_overlay_is_open = false;
     if (self->_normal_tex)
       self->SetMinMaxSize(self->_normal_tex->GetWidth(), self->_normal_tex->GetHeight());
 

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-01-20 06:47:42 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-01-25 11:34:37 +0000
@@ -118,6 +118,7 @@
   , dash_is_open_ (false)
   , grab_index_ (0)
   , painting_tray_ (false)
+  , last_hud_show_time_(0)
 {
   Timer timer;
   gfloat version;
@@ -206,9 +207,9 @@
 
      nux::NuxInitialize(0);
      wt = nux::CreateFromForeignWindow(cScreen->output(),
-				       glXGetCurrentContext(),
-				       &UnityScreen::initUnity,
-				       this);
+               glXGetCurrentContext(),
+               &UnityScreen::initUnity,
+               this);
 
      wt->RedrawRequested.connect(sigc::mem_fun(this, &UnityScreen::onRedrawRequested));
 
@@ -243,6 +244,9 @@
        uScreen->_fbo->onScreenSizeChanged (geometry);
      }
 
+     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));
@@ -301,19 +305,19 @@
 
      UBusServer* ubus = ubus_server_get_default();
      _ubus_handles[0] = ubus_server_register_interest(ubus,
-						      UBUS_LAUNCHER_START_KEY_NAV,
-						      (UBusCallback)&UnityScreen::OnLauncherStartKeyNav,
-						      this);
+                  UBUS_LAUNCHER_START_KEY_NAV,
+                  (UBusCallback)&UnityScreen::OnLauncherStartKeyNav,
+                  this);
 
      _ubus_handles[1] = ubus_server_register_interest(ubus,
-						      UBUS_LAUNCHER_END_KEY_NAV,
-						      (UBusCallback)&UnityScreen::OnLauncherEndKeyNav,
-						      this);
+                  UBUS_LAUNCHER_END_KEY_NAV,
+                  (UBusCallback)&UnityScreen::OnLauncherEndKeyNav,
+                  this);
 
      _ubus_handles[2] = ubus_server_register_interest(ubus,
-						      UBUS_QUICKLIST_END_KEY_NAV,
-						      (UBusCallback)&UnityScreen::OnQuicklistEndKeyNav,
-						      this);
+                  UBUS_QUICKLIST_END_KEY_NAV,
+                  (UBusCallback)&UnityScreen::OnQuicklistEndKeyNav,
+                  this);
 
      g_idle_add_full (G_PRIORITY_DEFAULT, &UnityScreen::initPluginActions, this, NULL);
      super_keypressed_ = false;
@@ -328,11 +332,11 @@
 
      BackgroundEffectHelper::updates_enabled = true;
 
-     ubus_manager_.RegisterInterest(UBUS_PLACE_VIEW_SHOWN, [&](GVariant * args) { 
+     ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, [&](GVariant * args) { 
        dash_is_open_ = true; 
        RaiseInputWindows(); 
      });
-     ubus_manager_.RegisterInterest(UBUS_PLACE_VIEW_HIDDEN, [&](GVariant * args) { dash_is_open_ = false; });
+     ubus_manager_.RegisterInterest(UBUS_OVERLAY_HIDDEN, [&](GVariant * args) { dash_is_open_ = false; });
       LOG_INFO(logger) << "UnityScreen constructed: " << timer.ElapsedSeconds() << "s";
   }
 }
@@ -372,7 +376,7 @@
       sout << "<Alt>" << XKeysymToString(above_tab_keysym);
 
       screen->removeAction(&optionGetAltTabNextWindow());
-      
+
       CompAction action = CompAction();
       action.keyFromString(sout.str());
       action.setState (CompAction::StateInitKey | CompAction::StateAutoGrab);
@@ -387,7 +391,7 @@
       sout << "<Alt><Shift>" << XKeysymToString(above_tab_keysym);
 
       screen->removeAction(&optionGetAltTabPrevWindow());
-      
+
       CompAction action = CompAction();
       action.keyFromString(sout.str());
       action.setState (CompAction::StateInitKey | CompAction::StateAutoGrab);
@@ -638,9 +642,9 @@
       uTrayWindow->gWindow->glAddGeometrySetCurrentIndex ( MAXSHORT);
       uTrayWindow->gWindow->glDrawGeometrySetCurrentIndex (MAXSHORT);
       uTrayWindow->gWindow->glDraw (oTransform, attrib, infiniteRegion,
-				     PAINT_WINDOW_TRANSFORMED_MASK |
-				     PAINT_WINDOW_BLEND_MASK |
-				     PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK);
+             PAINT_WINDOW_TRANSFORMED_MASK |
+             PAINT_WINDOW_BLEND_MASK |
+             PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK);
       uTrayWindow->gWindow->glDrawGeometrySetCurrentIndex (oldGlDrawGeometryIndex);
       uTrayWindow->gWindow->glAddGeometrySetCurrentIndex (oldGlAddGeometryIndex);
       uTrayWindow->gWindow->glDrawSetCurrentIndex (oldGlDrawIndex);
@@ -673,8 +677,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)
@@ -801,7 +805,7 @@
 {
   if (mShowdesktopHandler)
     if (mShowdesktopHandler->animate (ms))
-    { 
+    {
       delete mShowdesktopHandler;
       mShowdesktopHandler = NULL;
       return true;
@@ -830,7 +834,7 @@
    return false;
 
   if (w->state () & (CompWindowStateSkipPagerMask |
-		     CompWindowStateSkipTaskbarMask))
+         CompWindowStateSkipTaskbarMask))
     return false;
 
   if ((w->state () & CompWindowStateHiddenMask))
@@ -1225,7 +1229,7 @@
   PluginAdapter::Default()->NotifyCompizEvent(plugin, event, option);
   compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>::handleCompizEvent (plugin, event, option);
 
-  if (dash_is_open_ && 
+  if (dash_is_open_ &&
       strcmp(event, "start_viewport_switch") == 0)
   {
     ubus_server_send_message(ubus_server_get_default(), UBUS_PLACE_VIEW_CLOSE_REQUEST, NULL);
@@ -1433,7 +1437,7 @@
     grab_index_ = screen->pushGrab (screen->invisibleCursor(), "unity-switcher");
   if (!grab_index_)
     return false;
-  
+
   std::vector<unity::launcher::AbstractLauncherIcon*> results = launcher_controller_->GetAltTabIcons();
 
   screen->addAction(&optionGetAltTabRight());
@@ -1524,7 +1528,7 @@
     altTabInitiateCommon(action, state, options);
     switcher_controller_->Select(1); // always select the current application
   }
-  
+
   switcher_controller_->NextDetail();
 
   action->setState(action->state() | CompAction::StateTermKey);
@@ -1535,7 +1539,7 @@
 {
   if (switcher_controller_->Visible())
     switcher_controller_->PrevDetail();
-  
+
   return false;
 }
 
@@ -1584,6 +1588,35 @@
     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)
+    {
+      // less than 50 ms have passed, thats a tap
+      hud_controller_->ShowHideHud();
+      last_hud_show_time_ = 0;
+    }
+  } 
+  return false;
+}
+
 void UnityScreen::OnQuicklistEndKeyNav(GVariant* data, void* value)
 {
   UnityScreen* self = reinterpret_cast<UnityScreen*>(value);
@@ -1676,7 +1709,7 @@
   bool result = screen->initPluginForScreen(p);
   if (p->vTable->name() == "unityshell")
     initAltTabNextWindow();
-    
+
   return result;
 }
 
@@ -1689,8 +1722,8 @@
   return "Unity";
 }
 
-bool isNuxWindow (CompWindow* value) 
-{ 
+bool isNuxWindow (CompWindow* value)
+{
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
   auto id = value->id();
 
@@ -1717,7 +1750,7 @@
 void UnityScreen::RaiseInputWindows()
 {
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-  
+
   for (auto window : xwns)
   {
     CompWindow* cwin = screen->findWindow(window);
@@ -1842,7 +1875,7 @@
   if (!window->onCurrentDesktop ())
     return false;
 
-  /* Only withdrawn windows 
+  /* Only withdrawn windows
    * which are marked hidden
    * are excluded */
   if (!window->shaded () &&
@@ -1850,8 +1883,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;
@@ -1957,7 +1990,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);
@@ -2136,9 +2169,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;
@@ -2185,6 +2218,7 @@
 
       launcher.SetIconSize(optionGetIconSize() + 6, optionGetIconSize());
       dash_controller_->launcher_width = optionGetIconSize() + 18;
+      hud_controller_->launcher_width = optionGetIconSize() + 18;
 
       if (p)
       {
@@ -2360,6 +2394,10 @@
   /* 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());
+  LOG_INFO(logger) << "initLauncher-hud " << timer.ElapsedSeconds() << "s";
   
   // Setup Shortcut Hint
   InitHints();
@@ -2515,7 +2553,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-20 06:47:42 +0000
+++ plugins/unityshell/src/unityshell.h	2012-01-25 11:34:37 +0000
@@ -56,6 +56,8 @@
 #include <compiztoolbox/compiztoolbox.h>
 #include <dlfcn.h>
 
+#include "HudController.h"
+
 namespace unity
 {
 
@@ -192,6 +194,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);
@@ -260,6 +265,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_;
@@ -313,6 +319,7 @@
   CompWindowList         fullscreen_windows_;
   bool                   painting_tray_;
   unsigned int           tray_paint_mask_;
+  gint64                 last_hud_show_time_;
 
   ScreenEffectFramebufferObject::GLXGetProcAddressProc glXGetProcAddressP;
 
@@ -381,7 +388,7 @@
   UnityMinimizedHandler *mMinimizeHandler;
 
   UnityShowdesktopHandler             *mShowdesktopHandler;
-  
+
 private:
 
   guint  focusdesktop_handle_;

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2012-01-19 16:21:14 +0000
+++ plugins/unityshell/unityshell.xml.in	2012-01-25 11:34:37 +0000
@@ -40,8 +40,13 @@
             </requirement>
         </deps>
         <options>
-	          <group>
+            <group>
                 <_short>Behaviour</_short>
+                <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_reveal_edge" type="edge">
                     <_short>Reveal Mode</_short>
                     <_long>From which edge should the launcher reveal.</_long>
@@ -56,7 +61,7 @@
                     <max>1000</max>
                     <default>150</default>
                  </option>
-	         <option name="launcher_hide_mode" type="int">
+           <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>
@@ -78,16 +83,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>
@@ -132,37 +137,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">
@@ -170,11 +175,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>
@@ -333,7 +338,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 'standalone-clients/CMakeLists.txt'
--- standalone-clients/CMakeLists.txt	2012-01-17 11:30:30 +0000
+++ standalone-clients/CMakeLists.txt	2012-01-25 11:34:37 +0000
@@ -86,6 +86,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}/HomeView.cpp
                 ${UNITY_SRC}/HomeView.h
                 ${UNITY_SRC}/DashStyle.cpp
@@ -460,6 +464,35 @@
                )
 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}/DashSearchBarSpinner.cpp
+                ${UNITY_SRC}/HudSearchBar.cpp
+                ${UNITY_SRC}/HudButton.cpp
+                ${UNITY_SRC}/HudIcon.cpp
+                ${UNITY_SRC}/HudIcon.h
+                ${UNITY_SRC}/HudView.cpp
+                ${UNITY_SRC}/IMTextEntry.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/OverlayRenderer.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-01-25 11:34:37 +0000
@@ -0,0 +1,170 @@
+/*
+ * 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())
+      {
+        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"),
+                            1024, 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-01-23 13:07:40 +0000
+++ tests/CMakeLists.txt	2012-01-25 11:34:37 +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
@@ -164,17 +166,18 @@
 
 # tests that require dbus, must not require X
   add_executable(test-gtest-dbus
-                 test_categories.cpp
-                 test_filesystem_lenses.cpp
-                 test_filter.cpp
-                 test_indicator_entry.cpp
-                 test_lens.cpp
+#                 test_categories.cpp
+#                 test_filesystem_lenses.cpp
+#                 test_filter.cpp
+#                 test_indicator_entry.cpp
+#                 test_lens.cpp
                  test_main_dbus.cpp
-                 test_model.cpp
-                 test_utils.h
-                 test_ratings_filter.cpp
-                 test_results.cpp
-                 )
+#                 test_model.cpp
+#                 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-01-25 11:34:37 +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-01-25 11:34:37 +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-01-25 11:34:37 +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-01-25 11:34:37 +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,
@@ -32,8 +33,9 @@
 };
 
 static GMainLoop* loop_ = NULL;
-static ServiceLens* lens_ = NULL;
-static ServiceModel* model_ = NULL;
+//static ServiceLens* lens_ = NULL;
+//static ServiceModel* model_ = NULL;
+static ServiceHud* hud_ = NULL;
 
 gint
 main(gint argc, gchar** argv)
@@ -42,8 +44,9 @@
 
   loop_ = g_main_loop_new(NULL, FALSE);
 
-  lens_ = service_lens_new();
-  model_ = service_model_new();
+  //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;