Merge lp:~nick-dedekind/unity/lp857422.dash-mouse-steal into lp:unity

[Nick Dedekind]

Dash/Hud no longer steal mouse events outside their content area. Better draw handling of hud animation.

Resize input window relative to the size of the dash/hud. Now only encompasses the required content area.
Added some draw performance fixes for the hud. (only redraw when needed)

[Nick Dedekind (nick-dedekind)]

This is a bit of a cheeky fix.
The problem causing the events to be stolen is that the base window of the dash/hud takes the monitor geometry as it's own. The XInputWindow which is responsible for receiving the XEvents has the same geometry.

This branch side-steps this issue by resizing the XInputWindow to match the actual size of the dash/hud, so if a user clicks outside the dash, it doesnt receive the click.

[Omer Akram (om26er)]

Has conflicts?

[Nick Dedekind (nick-dedekind)]

Fixed conflicts.

[Brandon Schaefer (brandontschaefer)]

I checked with trunk and the launcher looks the same as trunk so we are good there :).

Other then that everything looks awesome :). The tests worked for me, and it works manually for me as well. The launcher works, the Window buttons works...

soo this branch looks good to me :)

review: Approve

=== modified file 'dash/DashController.cpp'
--- dash/DashController.cpp	2012-09-17 10:00:38 +0000
+++ dash/DashController.cpp	2012-09-18 17:41:27 +0000
@@ -66,13 +66,13 @@
   , timeline_animator_(90)
   , dbus_connect_cancellable_(g_cancellable_new())
 {
-  SetupRelayoutCallbacks();
   RegisterUBusInterests();
 
   ensure_timeout_.Run([&]() { EnsureDash(); return false; });
   timeline_animator_.animation_updated.connect(sigc::mem_fun(this, &Controller::OnViewShowHideFrame));
 
   SetupWindow();
+  UScreen::GetDefault()->changed.connect([&] (int, std::vector<nux::Geometry>&) { Relayout(true); });
 
   Settings::Instance().changed.connect([&]()
   {
@@ -97,7 +97,12 @@
 
 void Controller::SetupWindow()
 {
-  window_ = new nux::BaseWindow(dash::window_title);
+  window_ = new ResizingBaseWindow(dash::window_title, [this](nux::Geometry const& geo)
+  {
+    if (view_)
+      return GetInputWindowGeometry();
+    return geo;
+  });
   window_->SetBackgroundColor(nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
   window_->SetConfigureNotifyCallback(&Controller::OnWindowConfigure, this);
   window_->ShowWindow(false);
@@ -122,19 +127,13 @@
   layout->SetContentDistribution(nux::eStackLeft);
   layout->SetVerticalExternalMargin(0);
   layout->SetHorizontalExternalMargin(0);
-
   window_->SetLayout(layout);
+
+  window_->UpdateInputWindowGeometry();
+
   ubus_manager_.UnregisterInterest(UBUS_PLACE_ENTRY_ACTIVATE_REQUEST);
 }
 
-void Controller::SetupRelayoutCallbacks()
-{
-  GdkScreen* screen = gdk_screen_get_default();
-  auto relayout_cb = sigc::mem_fun(this, &Controller::Relayout);
-  sig_manager_.Add<void, GdkScreen*>(screen, "monitors-changed", relayout_cb);
-  sig_manager_.Add<void, GdkScreen*>(screen, "size-changed", relayout_cb);
-}
-
 void Controller::RegisterUBusInterests()
 {
   ubus_manager_.RegisterInterest(UBUS_DASH_EXTERNAL_ACTIVATION,
@@ -218,13 +217,19 @@
                         monitor_geo.height - panel_style.panel_height);
 }
 
-void Controller::Relayout(GdkScreen*screen)
+void Controller::Relayout(bool check_monitor)
 {
   EnsureDash();
 
+  if (check_monitor)
+  {
+    monitor_ = CLAMP(GetIdealMonitor(), 0, static_cast<int>(UScreen::GetDefault()->GetMonitors().size()-1));
+    printf("relayout on monitor:%d, monitor count:%d\n", monitor_, static_cast<int>(UScreen::GetDefault()->GetMonitors().size()));
+  }
+
   nux::Geometry geo = GetIdealWindowGeometry();
+  view_->Relayout();
   window_->SetGeometry(geo);
-  view_->Relayout();
   panel::Style &panel_style = panel::Style::Instance();
   view_->SetMonitorOffset(launcher_width, panel_style.panel_height);
 }
@@ -291,7 +296,11 @@
   window_->ShowWindow(true);
   window_->PushToFront();
   if (!Settings::Instance().is_standalone) // in standalone mode, we do not need an input window. we are one.
+  {
     window_->EnableInputWindow(true, dash::window_title, true, false);
+    // update the input window geometry. This causes the input window to match the actual size of the dash.
+    window_->UpdateInputWindowGeometry();
+  }
   window_->SetInputFocus();
   window_->CaptureMouseDownAnyWhereElse(true);
   window_->QueueDraw();
@@ -445,6 +454,14 @@
   }
 }
 
+nux::Geometry Controller::GetInputWindowGeometry()
+{
+  EnsureDash();
+  nux::Geometry const& window_geo(window_->GetGeometry());
+  nux::Geometry const& view_content_geo(view_->GetContentGeometry());
+  return nux::Geometry(window_geo.x, window_geo.y, view_content_geo.width, view_content_geo.height);
+}
+
 
 }
 }

=== modified file 'dash/DashController.h'
--- dash/DashController.h	2012-09-13 10:56:42 +0000
+++ dash/DashController.h	2012-09-18 17:41:27 +0000
@@ -27,12 +27,12 @@
 #include <NuxCore/Property.h>
 #include <NuxGraphics/GraphicsEngine.h>
 #include <Nux/Nux.h>
-#include <Nux/BaseWindow.h>
 
 #include "DashView.h"
 #include "unity-shared/Animator.h"
 #include "unity-shared/Introspectable.h"
 #include "unity-shared/UBusWrapper.h"
+#include "unity-shared/ResizingBaseWindow.h"
 
 namespace unity
 {
@@ -60,6 +60,7 @@
   void HideDash(bool restore_focus = true);
 
   bool IsVisible() const;
+  nux::Geometry GetInputWindowGeometry();
 
 protected:
   std::string GetName() const;
@@ -69,12 +70,11 @@
   void EnsureDash();
   void SetupWindow();
   void SetupDashView();
-  void SetupRelayoutCallbacks();
   void RegisterUBusInterests();
 
   nux::Geometry GetIdealWindowGeometry();
   int GetIdealMonitor();
-  void Relayout(GdkScreen*screen=NULL);
+  void Relayout(bool check_monitor =false);
 
   void OnMouseDownOutsideWindow(int x, int y, unsigned long bflags, unsigned long kflags);
   void OnScreenUngrabbed();
@@ -96,7 +96,7 @@
   static void OnWindowConfigure(int width, int height, nux::Geometry& geo, void* data);
 
 private:
-  nux::ObjectPtr<nux::BaseWindow> window_;
+  nux::ObjectPtr<ResizingBaseWindow> window_;
   int monitor_;
 
   bool visible_;
@@ -104,7 +104,6 @@
   DashView* view_;
 
   sigc::connection screen_ungrabbed_slot_;
-  glib::SignalManager sig_manager_;
   glib::TimeoutSeconds ensure_timeout_;
   Animator timeline_animator_;
   UBusManager ubus_manager_;

=== modified file 'dash/DashView.cpp'
--- dash/DashView.cpp	2012-09-18 13:29:09 +0000
+++ dash/DashView.cpp	2012-09-18 17:41:27 +0000
@@ -1078,5 +1078,10 @@
   return (view == nullptr) ? this : view;
 }
 
+nux::Geometry const& DashView::GetContentGeometry() const
+{
+  return content_geo_;  
+}
+
 }
 }

=== modified file 'dash/DashView.h'
--- dash/DashView.h	2012-08-17 07:28:10 +0000
+++ dash/DashView.h	2012-09-18 17:41:27 +0000
@@ -69,6 +69,8 @@
 
   nux::View* default_focus() const;
 
+  nux::Geometry const& GetContentGeometry() const;
+
 protected:
   void ProcessDndEnter();
 

=== modified file 'hud/HudAbstractView.h'
--- hud/HudAbstractView.h	2012-06-09 08:42:53 +0000
+++ hud/HudAbstractView.h	2012-09-18 17:41:27 +0000
@@ -48,8 +48,9 @@
   virtual void SearchFinished() = 0;
   virtual void SetIcon(std::string const& icon_name, unsigned int tile_size, unsigned int size, unsigned int padding) = 0;
   virtual void SetQueries(Hud::Queries queries) = 0;
-  virtual void SetWindowGeometry(nux::Geometry const& absolute_geo, nux::Geometry const& geo) = 0;
+  virtual void SetMonitorOffset(int x, int y) = 0;
   virtual void ShowEmbeddedIcon(bool show) = 0;
+  virtual nux::Geometry GetContentGeometry() = 0;
 
   virtual nux::View* default_focus() const = 0;
 
@@ -58,6 +59,7 @@
   sigc::signal<void, std::string> search_activated;
   sigc::signal<void, Query::Ptr> query_activated;
   sigc::signal<void, Query::Ptr> query_selected;
+  sigc::signal<void> layout_changed;
 };
 
 } // namespace hud

=== modified file 'hud/HudController.cpp'
--- hud/HudController.cpp	2012-09-17 10:00:38 +0000
+++ hud/HudController.cpp	2012-09-18 17:41:27 +0000
@@ -54,7 +54,7 @@
 {
   LOG_DEBUG(logger) << "hud startup";
   SetupWindow();
-  UScreen::GetDefault()->changed.connect([&] (int, std::vector<nux::Geometry>&) { Relayout(); });
+  UScreen::GetDefault()->changed.connect([&] (int, std::vector<nux::Geometry>&) { Relayout(true); });
 
   ubus.RegisterInterest(UBUS_HUD_CLOSE_REQUEST, sigc::mem_fun(this, &Controller::OnExternalHideHud));
 
@@ -90,7 +90,12 @@
   // Since BaseWindow is a View it is initially unowned.  This means that the first
   // reference that is taken grabs ownership of the pointer.  Since the smart pointer
   // references it, it becomes the owner, so no need to adopt the pointer here.
-  window_ = new nux::BaseWindow("Hud");
+  window_ = new ResizingBaseWindow("Hud", [this](nux::Geometry const& geo)
+  {
+    if (view_)
+      return GetInputWindowGeometry();
+    return geo;
+  });
   window_->SetBackgroundColor(nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
   window_->SetConfigureNotifyCallback(&Controller::OnWindowConfigure, this);
   window_->ShowWindow(false);
@@ -117,6 +122,8 @@
   layout_->AddView(view_, 1, nux::MINOR_POSITION_TOP);
   window_->SetLayout(layout_);
 
+  window_->UpdateInputWindowGeometry();
+
   view_->mouse_down_outside_pointer_grab_area.connect(sigc::mem_fun(this, &Controller::OnMouseDownOutsideWindow));
 
   LOG_DEBUG(logger) << "connecting to signals";
@@ -124,6 +131,7 @@
   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));
+  view_->layout_changed.connect(sigc::bind(sigc::mem_fun(this, &Controller::Relayout), nullptr));
   // Add to the debug introspection.
   AddChild(view_);
 }
@@ -155,13 +163,15 @@
 
 void Controller::EnsureHud()
 {
-  LOG_DEBUG(logger) << "Initializing Hud";
-
   if (!window_)
+  {
+    LOG_DEBUG(logger) << "Initializing Hud Window";
     SetupWindow();
+  }
 
   if (!view_)
   {
+    LOG_DEBUG(logger) << "Initializing Hud View";
     SetupHudView();
     Relayout();
   }
@@ -212,16 +222,20 @@
   return geo;
 }
 
-void Controller::Relayout()
+void Controller::Relayout(bool check_monitor)
 {
   EnsureHud();
-  nux::Geometry const& content_geo = view_->GetGeometry();
+
+  if (check_monitor)
+  {
+    monitor_index_ = CLAMP(GetIdealMonitor(), 0, static_cast<int>(UScreen::GetDefault()->GetMonitors().size()-1));
+  }
   nux::Geometry const& geo = GetIdealWindowGeometry();
 
+  view_->Relayout();
   window_->SetGeometry(geo);
-  layout_->SetMinMaxSize(content_geo.width, content_geo.height);
-  view_->SetWindowGeometry(window_->GetAbsoluteGeometry(), window_->GetGeometry());
-  view_->Relayout();
+  panel::Style &panel_style = panel::Style::Instance();
+  view_->SetMonitorOffset(launcher_width, panel_style.panel_height);
 }
 
 void Controller::OnMouseDownOutsideWindow(int x, int y,
@@ -255,7 +269,15 @@
 {
   LOG_DEBUG(logger) << "External Hiding the hud";
   EnsureHud();
-  HideHud();
+
+  if (variant)
+  {
+    HideHud(g_variant_get_boolean(variant));
+  }
+  else
+  {
+    HideHud();
+  }
 }
 
 void Controller::ShowHideHud()
@@ -353,6 +375,7 @@
   window_->ShowWindow(true);
   window_->PushToFront();
   window_->EnableInputWindow(true, "Hud", true, false);
+  window_->UpdateInputWindowGeometry();
   window_->SetInputFocus();
   window_->CaptureMouseDownAnyWhereElse(true);
   view_->CaptureMouseDownAnyWhereElse(true);
@@ -363,7 +386,6 @@
   visible_ = true;
 
   StartShowHideTimeline();
-  view_->SetWindowGeometry(window_->GetAbsoluteGeometry(), window_->GetGeometry());
 
   // hide the launcher
   GVariant* message_data = g_variant_new("(b)", TRUE);
@@ -504,6 +526,15 @@
     .add("locked_to_launcher", IsLockedToLauncher(monitor_index_));
 }
 
+nux::Geometry Controller::GetInputWindowGeometry()
+{
+  EnsureHud();
+  nux::Geometry const& window_geo(window_->GetGeometry());
+  nux::Geometry const& view_content_geo(view_->GetContentGeometry());
+  return nux::Geometry(window_geo.x, window_geo.y, view_content_geo.width, view_content_geo.height);
+}
+
+
 
 }
 }

=== modified file 'hud/HudController.h'
--- hud/HudController.h	2012-09-13 10:56:42 +0000
+++ hud/HudController.h	2012-09-18 17:41:27 +0000
@@ -24,14 +24,15 @@
 
 #include <gdk/gdk.h>
 #include <UnityCore/Hud.h>
+#include <UnityCore/GLibSignal.h>
 
 #include <NuxCore/Property.h>
 #include <NuxGraphics/GraphicsEngine.h>
 #include <Nux/Nux.h>
-#include <Nux/BaseWindow.h>
 
 #include "unity-shared/Animator.h"
 #include "unity-shared/UBusWrapper.h"
+#include "unity-shared/ResizingBaseWindow.h"
 #include "HudView.h"
 
 namespace unity
@@ -59,6 +60,8 @@
   void HideHud(bool restore_focus = true);
   bool IsVisible();
 
+  nux::Geometry GetInputWindowGeometry();
+
 protected:
   // Introspectable
   std::string GetName() const;
@@ -75,7 +78,7 @@
   bool IsLockedToLauncher(int monitor);
 
   nux::Geometry GetIdealWindowGeometry();
-  void Relayout();
+  void Relayout(bool check_monitor =false);
 
   void OnMouseDownOutsideWindow(int x, int y, unsigned long bflags, unsigned long kflags);
   void OnScreenUngrabbed();
@@ -96,8 +99,9 @@
   void OnQueriesFinished(Hud::Queries queries);
 
 private:
-  nux::ObjectPtr<nux::BaseWindow> window_;
+  nux::ObjectPtr<ResizingBaseWindow> window_;
   UBusManager ubus;
+  glib::SignalManager sig_manager_;
   Hud hud_service_;
   bool visible_;
   bool need_show_;

=== modified file 'hud/HudView.cpp'
--- hud/HudView.cpp	2012-09-13 10:56:42 +0000
+++ hud/HudView.cpp	2012-09-18 17:41:27 +0000
@@ -61,10 +61,10 @@
   : AbstractView()
   , button_views_(nullptr)
   , visible_(false)
+  , timeline_animating_(false)
   , start_time_(0)
   , last_known_height_(0)
   , current_height_(0)
-  , timeline_need_more_draw_(false)
   , selected_button_(0)
   , show_embedded_icon_(true)
   , keyboard_stole_focus_(false)
@@ -122,6 +122,12 @@
 {
 }
 
+void View::SetMonitorOffset(int x, int y)
+{
+  renderer_.x_offset = x;
+  renderer_.y_offset = y;
+}
+
 void View::ProcessGrowShrink()
 {
   float diff = g_get_monotonic_time() - start_time_;
@@ -129,24 +135,25 @@
   // only animate if we are after our defined pause time
   if (diff > pause_before_grow_length)
   {
-   float progress = (diff - pause_before_grow_length) / grow_anim_length;
-   int last_height = last_known_height_;
-   int new_height = 0;
-
-   if (last_height < target_height)
-   {
-     // grow
-     new_height = last_height + ((target_height - last_height) * progress);
-   }
-   else
-   {
-     //shrink
-     new_height = last_height - ((last_height - target_height) * progress);
-   }
-
-   LOG_DEBUG(logger) << "resizing to " << target_height << " (" << new_height << ")"
+    float progress = (diff - pause_before_grow_length) / grow_anim_length;
+    int last_height = last_known_height_;
+    int new_height = 0;
+
+    if (last_height < target_height)
+    {
+      // grow
+      new_height = last_height + ((target_height - last_height) * progress);
+    }
+    else
+    {
+      //shrink
+      new_height = last_height - ((last_height - target_height) * progress);
+    }
+    
+
+    LOG_DEBUG(logger) << "resizing to " << target_height << " (" << new_height << ")"
                      << "View height: " << GetGeometry().height;
-   current_height_ = new_height;
+    current_height_ = new_height;
   }
 
   for (auto button : buttons_)
@@ -154,14 +161,23 @@
     button->SetSkipDraw((button->GetAbsoluteY() + button->GetBaseHeight()) > (GetAbsoluteY() + current_height_));
   }
 
-  QueueDraw();
-
   if (diff > grow_anim_length + pause_before_grow_length)
   {
     // ensure we are at our final location and update last known height
     current_height_ = target_height;
     last_known_height_ = target_height;
-    timeline_need_more_draw_ = false;
+
+    layout_changed.emit();
+    timeline_idle_.reset();
+    timeline_animating_ = false;
+  }
+  else
+  {
+    timeline_idle_.reset(new glib::Timeout(0, [this]
+    {
+      QueueDraw();
+      return false;
+    }));
   }
 }
 
@@ -187,27 +203,6 @@
   QueueDraw();
 }
 
-long View::PostLayoutManagement(long LayoutResult)
-{
-  Relayout();
-  if (GetGeometry().height != last_known_height_)
-  {
-    // Start the timeline of drawing the dash resize
-    if (timeline_need_more_draw_)
-    {
-      // already started, just reset the last known height
-      last_known_height_ = current_height_;
-    }
-
-    timeline_need_more_draw_ = true;
-    start_time_ = g_get_monotonic_time();
-    QueueDraw();
-  }
-
-  return LayoutResult;
-}
-
-
 nux::View* View::default_focus() const
 {
   return search_bar_->text_entry();
@@ -361,14 +356,6 @@
   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()
 {
   dash::Style& style = dash::Style::Instance();
@@ -405,6 +392,17 @@
       content_layout_->AddLayout(button_views_.GetPointer(), 1, nux::MINOR_POSITION_LEFT);
     }
 
+    content_layout_->OnGeometryChanged.connect([&](nux::Area*, nux::Geometry& geo)
+    {
+      if (!timeline_animating_)
+      {
+        timeline_animating_ = true;
+        start_time_ = g_get_monotonic_time();
+        QueueDraw();
+      }
+    });
+
+
     layout_->AddLayout(content_layout_.GetPointer(), 1, nux::MINOR_POSITION_TOP);
   }
 
@@ -450,14 +448,12 @@
 
 void View::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
 {
-  if (timeline_need_more_draw_)
-  {
+  if (timeline_animating_)
     ProcessGrowShrink();
-  }
 
   nux::Geometry draw_content_geo(layout_->GetGeometry());
   draw_content_geo.height = current_height_;
-  renderer_.DrawFull(gfx_context, draw_content_geo, absolute_window_geometry_, window_geometry_, true);
+  renderer_.DrawFull(gfx_context, draw_content_geo, GetAbsoluteGeometry(), GetGeometry(), true);
 }
 
 void View::DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw)
@@ -465,7 +461,7 @@
   nux::Geometry draw_content_geo(layout_->GetGeometry());
   draw_content_geo.height = current_height_;
 
-  renderer_.DrawInner(gfx_context, draw_content_geo, absolute_window_geometry_, window_geometry_);
+  renderer_.DrawInner(gfx_context, draw_content_geo, GetAbsoluteGeometry(), GetGeometry());
 
   gfx_context.PushClippingRectangle(draw_content_geo);
 
@@ -492,16 +488,7 @@
   }
   gfx_context.PopClippingRectangle();
 
-  renderer_.DrawInnerCleanup(gfx_context, draw_content_geo, absolute_window_geometry_, window_geometry_);
-
-  if (timeline_need_more_draw_ && !timeline_idle_)
-  {
-    timeline_idle_.reset(new glib::Idle([&] () {
-      QueueDraw();
-      timeline_idle_.reset();
-      return false;
-    }));
-  }
+  renderer_.DrawInnerCleanup(gfx_context, draw_content_geo, GetAbsoluteGeometry(), GetGeometry());
 }
 
 void View::MouseStealsHudButtonFocus()
@@ -769,6 +756,14 @@
   return search_bar_->text_entry();
 }
 
+nux::Geometry View::GetContentGeometry()
+{
+  nux::Geometry geo(content_geo_);
+  geo.height = current_height_;
+  return geo;
+}
+
+
 }
 }
 

=== modified file 'hud/HudView.h'
--- hud/HudView.h	2012-09-04 18:15:34 +0000
+++ hud/HudView.h	2012-09-18 17:41:27 +0000
@@ -60,7 +60,9 @@
   void AboutToShow();
   void AboutToHide();
 
-  void SetWindowGeometry(nux::Geometry const& absolute_geo, nux::Geometry const& geo);
+  void SetMonitorOffset(int x, int y);
+  
+  nux::Geometry GetContentGeometry();
 
 protected:
   virtual Area* FindKeyFocusArea(unsigned int event_type,
@@ -69,7 +71,6 @@
 
   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);
@@ -110,14 +111,12 @@
   Hud::Queries queries_;
   nux::Geometry content_geo_;
   OverlayRenderer renderer_;
-  nux::Geometry window_geometry_;
-  nux::Geometry absolute_window_geometry_;
   glib::Source::UniquePtr timeline_idle_;
+  bool timeline_animating_;
 
   guint64 start_time_;
   int last_known_height_;
   int current_height_;
-  bool timeline_need_more_draw_;
   int selected_button_;
   bool show_embedded_icon_;
   bool activated_signal_sent_;

=== modified file 'hud/StandaloneHud.cpp'
--- hud/StandaloneHud.cpp	2012-06-01 15:24:14 +0000
+++ hud/StandaloneHud.cpp	2012-09-18 17:41:27 +0000
@@ -69,7 +69,7 @@
 
   hud_view_ = new unity::hud::View();
 
-  layout->AddView (hud_view_, 0, nux::MINOR_POSITION_TOP);
+  layout->AddView (hud_view_, 1, nux::MINOR_POSITION_TOP);
   nux::GetWindowCompositor().SetKeyFocusArea(hud_view_->default_focus());
 
   nux::GetWindowThread()->SetLayout (layout);
@@ -109,9 +109,6 @@
   });
 
   hud_service_.RequestQuery("");
- 
-  hud_view_->SetWindowGeometry(layout->GetAbsoluteGeometry(), layout->GetGeometry());
-
 }
 
 void TestRunner::InitWindowThread(nux::NThread* thread, void* InitData)

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-09-18 01:41:46 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-09-18 17:41:27 +0000
@@ -913,6 +913,33 @@
   }
 }
 
+bool UnityScreen::DoesPointIntersectUnityGeos(nux::Point const& pt)
+{
+  auto launchers = launcher_controller_->launchers();
+  for (auto launcher : launchers)
+  {
+    nux::Geometry hud_geo = launcher->GetAbsoluteGeometry();
+
+    if (launcher->Hidden())
+      continue;
+
+    if (hud_geo.IsInside(pt))
+    {
+      return true;
+    }
+  }
+
+  for (nux::Geometry &panel_geo : panel_controller_->GetGeometries ())
+  {
+    if (panel_geo.IsInside(pt))
+    {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void UnityWindow::enterShowDesktop ()
 {
   if (!mShowdesktopHandler)
@@ -1435,12 +1462,26 @@
         if (CompWindow *w = screen->findWindow(ss->getSelectedWindow()))
           skip_other_plugins = UnityWindow::get(w)->handleEvent(event);
       }
-      if (launcher_controller_->IsOverlayOpen())
+
+
+      if (dash_controller_->IsVisible())
       {
-        int monitor_with_mouse = UScreen::GetDefault()->GetMonitorWithMouse();
-        if (overlay_monitor_ != monitor_with_mouse)
+        nux::Point pt(event->xbutton.x_root, event->xbutton.y_root);
+        nux::Geometry dash_geo = dash_controller_->GetInputWindowGeometry();
+
+        if (!dash_geo.IsInside(pt) && !DoesPointIntersectUnityGeos(pt))
         {
           dash_controller_->HideDash(false);
+        }
+      }
+
+      if (hud_controller_->IsVisible())
+      {
+        nux::Point pt(event->xbutton.x_root, event->xbutton.y_root);
+        nux::Geometry hud_geo = hud_controller_->GetInputWindowGeometry();
+
+        if (!hud_geo.IsInside(pt) && !DoesPointIntersectUnityGeos(pt))
+        {
           hud_controller_->HideHud(false);
         }
       }
@@ -2683,6 +2724,7 @@
   return pos;
 }
 
+
 bool UnityWindow::place(CompPoint& pos)
 {
   bool was_maximized = PluginAdapter::Default ()->MaximizeIfBigEnough(window);

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-09-18 01:41:46 +0000
+++ plugins/unityshell/src/unityshell.h	2012-09-18 17:41:27 +0000
@@ -190,6 +190,8 @@
   switcher::Controller::Ptr switcher_controller();
   launcher::Controller::Ptr launcher_controller();
 
+  bool DoesPointIntersectUnityGeos(nux::Point const& pt);
+
 protected:
   std::string GetName() const;
   void AddProperties(GVariantBuilder* builder);

=== modified file 'tests/autopilot/unity/emulators/dash.py'
--- tests/autopilot/unity/emulators/dash.py	2012-09-13 10:56:42 +0000
+++ tests/autopilot/unity/emulators/dash.py	2012-09-18 17:41:27 +0000
@@ -155,6 +155,10 @@
         active_lens_name = self.view.get_lensbar().active_lens
         return self.view.get_lensview_by_name(active_lens_name)
 
+    @property
+    def geometry(self):
+        return (self.view.x, self.view.y, self.view.width, self.view.height)
+
 
 class DashController(UnityIntrospectionObject):
     """The main dash controller object."""

=== modified file 'tests/autopilot/unity/tests/test_dash.py'
--- tests/autopilot/unity/tests/test_dash.py	2012-09-18 01:41:46 +0000
+++ tests/autopilot/unity/tests/test_dash.py	2012-09-18 17:41:27 +0000
@@ -107,6 +107,39 @@
         self.dash.reveal_application_lens()
         self.assertThat(self.dash.active_lens, Eventually(Equals('applications.lens')))
 
+    def test_closes_mouse_down_outside(self):
+        """Test that a mouse down outside of the dash closes the dash."""
+
+        self.dash.ensure_visible()
+        current_monitor = self.dash.monitor
+
+        (x,y,w,h) = self.dash.geometry
+        (screen_x,screen_y,screen_w,screen_h) = self.screen_geo.get_monitor_geometry(current_monitor)
+        
+        self.mouse.move(x + w + (screen_w-((screen_x-x)+w))/2, y + h + (screen_h-((screen_y-y)+h))/2)
+        self.mouse.click()
+        
+        self.assertThat(self.dash.visible, Eventually(Equals(False)))
+
+    def test_closes_then_focuses_window_on_mouse_down(self):
+        """If 2 windows are open with 1 maximized and the non-maxmized
+        focused. Then from the Dash clicking on the maximized window
+        must focus that window and close the dash.
+        """
+        char_win = self.start_app("Character Map")
+        self.keybinding("window/maximize")
+        self.start_app("Calculator")
+
+        self.dash.ensure_visible()
+
+        #Click bottom right of the screen
+        w = self.screen_geo.get_screen_width()
+        h = self.screen_geo.get_screen_height()
+        self.mouse.move(w,h)
+        self.mouse.click()
+
+        self.assertProperty(char_win, is_active=True)
+
 
 class DashSearchInputTests(DashTestCase):
     """Test features involving input to the dash search"""

=== modified file 'tests/autopilot/unity/tests/test_hud.py'
--- tests/autopilot/unity/tests/test_hud.py	2012-09-18 01:41:46 +0000
+++ tests/autopilot/unity/tests/test_hud.py	2012-09-18 17:41:27 +0000
@@ -409,6 +409,38 @@
         self.keyboard.type("HasFocus")
         self.assertThat(self.hud.search_string, Eventually(Equals("HasFocus")))
 
+    def test_closes_mouse_down_outside(self):
+        """Test that a mouse down outside of the hud closes the hud."""
+
+        self.hud.ensure_visible()
+        current_monitor = self.hud.monitor
+
+        (x,y,w,h) = self.hud.geometry
+        (screen_x,screen_y,screen_w,screen_h) = self.screen_geo.get_monitor_geometry(current_monitor)
+        
+        self.mouse.move(x + w + (screen_w-((screen_x-x)+w))/2, y + h + (screen_h-((screen_y-y)+h))/2)
+        self.mouse.click()
+        
+        self.assertThat(self.hud.visible, Eventually(Equals(False)))
+
+    def test_closes_then_focuses_window_on_mouse_down(self):
+        """If 2 windows are open with 1 maximized and the non-maxmized
+        focused. Then from the Hud clicking on the maximized window
+        must focus that window and close the hud.
+        """
+        char_win = self.start_app("Character Map")
+        self.keybinding("window/maximize")
+        self.start_app("Calculator")
+
+        self.hud.ensure_visible()
+
+        #Click bottom right of the screen
+        w = self.screen_geo.get_screen_width()
+        h = self.screen_geo.get_screen_height()
+        self.mouse.move(w,h)
+        self.mouse.click()
+
+        self.assertProperty(char_win, is_active=True)
 
 class HudLauncherInteractionsTests(HudTestsBase):
 

=== modified file 'tests/test_hud_controller.cpp'
--- tests/test_hud_controller.cpp	2012-07-04 02:37:23 +0000
+++ tests/test_hud_controller.cpp	2012-09-18 17:41:27 +0000
@@ -44,12 +44,13 @@
   MOCK_METHOD0(SearchFinished, void());
   MOCK_METHOD4(SetIcon, void(std::string const&, unsigned int tile_size, unsigned int size, unsigned int padding));
   MOCK_METHOD1(SetQueries, void(hud::Hud::Queries queries));
-  MOCK_METHOD2(SetWindowGeometry, void(nux::Geometry const& absolute_geo, nux::Geometry const& geo));
+  MOCK_METHOD2(SetMonitorOffset, void(int x, int y));
   MOCK_METHOD1(ShowEmbeddedIcon, void(bool show));
   MOCK_CONST_METHOD0(default_focus, nux::View*());
   MOCK_CONST_METHOD0(GetName, std::string());
   MOCK_METHOD1(AddProperties, void(GVariantBuilder*));
   MOCK_METHOD2(Draw, void(nux::GraphicsEngine&, bool));
+  MOCK_METHOD0(GetContentGeometry, nux::Geometry());
 
 };
 

=== added file 'unity-shared/ResizingBaseWindow.h'
--- unity-shared/ResizingBaseWindow.h	1970-01-01 00:00:00 +0000
+++ unity-shared/ResizingBaseWindow.h	2012-09-18 17:41:27 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef RESIZEDINPUTWINDOW_BASEWINDOW_H
+#define RESIZEDINPUTWINDOW_BASEWINDOW_H
+
+#include <Nux/BaseWindow.h>
+
+namespace unity
+{
+
+class ResizingBaseWindow : public nux::BaseWindow
+{
+public:
+  ResizingBaseWindow(const char *WindowName, std::function<nux::Geometry (nux::Geometry const&)> geo_func)
+  : BaseWindow(WindowName, NUX_TRACKER_LOCATION)
+  {
+    geo_func_ = geo_func;
+  }
+
+  void UpdateInputWindowGeometry()
+  {
+    if (m_input_window && m_input_window_enabled)
+      m_input_window->SetGeometry(geo_func_(GetGeometry()));
+  }
+
+  virtual void SetGeometry(const nux::Geometry &geo)
+  {
+     Area::SetGeometry(geo);
+     UpdateInputWindowGeometry();
+  }
+
+private:
+  std::function<nux::Geometry (nux::Geometry const&)> geo_func_;
+};
+
+}
+#endif // RESIZEDINPUTWINDOW_BASEWINDOW_H