Merge lp:~unity-team/unity/unity.hide-cleanup into lp:unity

[Jason Smith]

[Didier Roche-Tolomelli (didrocks)]

Thanks Jason, that's an amazing work!

I'll fix the remaining issues in a further branch. I'm sure that setting last_action_activate to false in the set_hidden() function has some side effect as I did it that way before

280 + _hide_machine->SetQuirk (LauncherHideMachine::LAUNCHER_HIDDEN, hidden);
281 + _hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);

On that part:
This is wrong, I'm sure that we get false positive here, because on some workspace transition, with a slow cpu maybe, the computation is redone between a two ws switch and the we get false positive like: apps in fullscreen on ws1 -> apps in fullscreen on ws2 if the refresh is done at the wrong time.

I'll keep it removed for now, but keeping that in mind…

235 - if (strcmp (event, "begin_viewport_switch") == 0)
1236 - {
1237 - launcher->EnableHiddenStateCheck (false);
1238 - }
1239 - if (strcmp (event, "end_viewport_switch") == 0)
1240 - {
1241 - // compute again the list of all window on the new viewport
1242 - // to decide if we should or not hide the launcher
1243 - launcher->EnableHiddenStateCheck (true);
1244 - launcher->CheckWindowOverLauncher ();
1245 - }
1246 -
1247 -
1248 + launcher->CheckWindowOverLauncher ();

We still have some duplicated variables between the QUIRK and the launcher, I'll ensure to remove them properly.

Also, some false positive, like:
- activate the keynav, mouse doesn't move (but was over launcher), end keynav without doing any move: launcher stays visible
- exiting keynav should exit immediatly.

and as we discussed, fixing the fade effect on bfb as well. Seems you pushed th 0x0 in two places, will get it back to one/ (and push the slide effect by default as well)

(ok, this is more or less ends up as my TODO :))

Apart from those, very nice refactoring! Starting working from there and waiting for the nux branch to be approved and merged! :)

review: Approve

[Alejandro Piñeiro (apinheiro)]

I have just tested it, and the orca support on the launcher is still working (although right now this is true with at-spi2, not with at-spi). As I told Jason Smith on IRC, current a11y support on the Launcher is based on the icon selection change (signal selection_change) and the Launcher having the focus (signals OnStartFocus and OnEndFocus) and this branch doesn't modify it.

In the case of places, right now the support is zero, as I just made some user-tests, and start to review the object hierarchy. But as the real support is zero, it doesn't matter if it changes suddenly.

So from my part it is ok.

Anyway, this also touches the Panel. So as Rodrigo was the one implementing the a11y support for the panel-service, I will let him to review this part.

review: Approve

=== modified file 'src/Launcher.cpp'
--- src/Launcher.cpp	2011-03-18 18:35:33 +0000
+++ src/Launcher.cpp	2011-03-21 19:14:32 +0000
@@ -51,6 +51,10 @@
 
 #define BACKLIGHT_STRENGTH  0.9f
 
+#define TRIGGER_SQR_RADIUS 9
+
+#define MOUSE_DEADZONE 15
+
 #define S_DBUS_NAME  "com.canonical.Unity.Launcher"
 #define S_DBUS_PATH  "/com/canonical/Unity/Launcher"
 #define S_DBUS_IFACE "com.canonical.Unity.Launcher"
@@ -220,6 +224,9 @@
     _parent = parent;
     _screen = screen;
     _active_quicklist = 0;
+    
+    _hide_machine = new LauncherHideMachine ();
+    _hide_machine->should_hide_changed.connect (sigc::mem_fun (this, &Launcher::SetHidden));
 
     m_Layout = new nux::HLayout(NUX_TRACKER_LOCATION);
 
@@ -251,6 +258,11 @@
     
     PluginAdapter::Default ()->window_mapped.connect (sigc::mem_fun (this, &Launcher::OnWindowMapped));
     PluginAdapter::Default ()->window_unmapped.connect (sigc::mem_fun (this, &Launcher::OnWindowUnmapped));
+    
+    PluginAdapter::Default ()->initiate_spread.connect (sigc::mem_fun (this, &Launcher::OnPluginStateChanged));
+    PluginAdapter::Default ()->initiate_expo.connect (sigc::mem_fun (this, &Launcher::OnPluginStateChanged));
+    PluginAdapter::Default ()->terminate_spread.connect (sigc::mem_fun (this, &Launcher::OnPluginStateChanged));
+    PluginAdapter::Default ()->terminate_expo.connect (sigc::mem_fun (this, &Launcher::OnPluginStateChanged));
 
     m_ActiveTooltipIcon = NULL;
     m_ActiveMenuIcon = NULL;
@@ -327,11 +339,9 @@
       _superkey_labels[i] = cairoToTexture2D ((char) ('0' + ((i  + 1) % 10)), _icon_size, _icon_size);
 
     _enter_y                = 0;
-    _dnd_security           = 15;
     _launcher_drag_delta    = 0;
     _dnd_delta_y            = 0;
     _dnd_delta_x            = 0;
-    _autohide_handle        = 0;
     _autoscroll_handle      = 0;
     _redraw_handle          = 0;
     _start_dragicon_handle  = 0;
@@ -339,25 +349,19 @@
     _floating               = false;
     _hovered                = false;
     _hidden                 = false;
-    _hidden_state_check     = true;
-    _mouse_inside_launcher  = false;
-    _mouse_inside_trigger   = false;
-    _mouseover_launcher_locked = false;
-    _super_show_launcher    = false;
-    _navmod_show_launcher   = false;
-    _placeview_show_launcher = false;
-    _window_over_launcher   = false;
-    _hide_on_drag_hover     = false;
     _render_drag_window     = false;
-    _dnd_window_is_mapped   = false;
     _drag_edge_touching     = false;
     _backlight_mode         = BACKLIGHT_NORMAL;
     _last_button_press      = 0;
     _selection_atom         = 0;
+    
+    _check_window_over_launcher   = true;
+    _postreveal_mousemove_delta_x = 0;
+    _postreveal_mousemove_delta_y = 0;
 
     // set them to 1 instead of 0 to avoid :0 in case something is racy
-    _trigger_width = 1;
-    _trigger_height = 1;
+    _bfb_width = 1;
+    _bfb_height = 1;
 
     // 0 out timers to avoid wonky startups
     int i;
@@ -379,8 +383,8 @@
                                    (UBusCallback)&Launcher::OnPlaceViewHidden,
                                    this);
 
-    ubus_server_register_interest (ubus, UBUS_HOME_BUTTON_TRIGGER_UPDATE,
-                                   (UBusCallback)&Launcher::OnTriggerUpdate,
+    ubus_server_register_interest (ubus, UBUS_HOME_BUTTON_BFB_UPDATE,
+                                   (UBusCallback)&Launcher::OnBFBUpdate,
                                    this);
                                    
     ubus_server_register_interest (ubus, UBUS_LAUNCHER_ACTION_DONE,
@@ -533,8 +537,8 @@
 void
 Launcher::startKeyNavMode ()
 {
-  _navmod_show_launcher = true;
-  EnsureHiddenState ();
+  _hide_machine->SetQuirk (LauncherHideMachine::KEY_NAV_ACTIVE, true);
+  _hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);
   
   GrabKeyboard ();
   GrabPointer ();
@@ -552,14 +556,14 @@
   Launcher *self = (Launcher*) data;
       
   // move focus to key nav mode when activated
-  if (!(self->_navmod_show_launcher))
+  if (!(self->_hide_machine->GetQuirk (LauncherHideMachine::KEY_NAV_ACTIVE)))
     return false;
   
   if (self->_last_icon_index == -1)
      self->_current_icon_index = 0;
    else
      self->_current_icon_index = self->_last_icon_index;
-   self->NeedRedraw ();
+   self->EnsureAnimation ();
 
    ubus_server_send_message (ubus_server_get_default (),
                              UBUS_LAUNCHER_START_KEY_NAV,
@@ -587,13 +591,12 @@
 void
 Launcher::exitKeyNavMode ()
 {
-  if (!_navmod_show_launcher)
+  if (!_hide_machine->GetQuirk (LauncherHideMachine::KEY_NAV_ACTIVE))
     return;
-    
+  
   UnGrabKeyboard ();
   UnGrabPointer ();
-  _navmod_show_launcher = false;
-  EnsureHiddenState ();
+  _hide_machine->SetQuirk (LauncherHideMachine::KEY_NAV_ACTIVE, false);
 
   _current_icon_index = -1;
   _last_icon_index = _current_icon_index;
@@ -619,7 +622,7 @@
   g_variant_builder_add (builder, "{sv}", "hovered", g_variant_new_boolean (_hovered));
   g_variant_builder_add (builder, "{sv}", "hidemode", g_variant_new_int32 (_hidemode));
   g_variant_builder_add (builder, "{sv}", "hidden", g_variant_new_boolean (_hidden));
-  g_variant_builder_add (builder, "{sv}", "mouse-inside-launcher", g_variant_new_boolean (_mouse_inside_launcher));
+  g_variant_builder_add (builder, "{sv}", "mouse-over-launcher", g_variant_new_boolean (_hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER)));
 }
 
 void Launcher::SetMousePosition (int x, int y)
@@ -658,15 +661,12 @@
 {
     
     // bfb position progress. Go from GetAutohidePositionMin() -> GetAutohidePositionMax() linearly
-    if (_mouse_inside_trigger && !_mouseover_launcher_locked)
+    if (_hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_BFB) && _hidden)
     {
-        // all this code should only be triggered when _hidden is true
-        if (!_hidden)
-          return 0.0f;
-          
-        // "dead" zone
-        if ((_trigger_mouse_position.x < 3) && (_trigger_mouse_position.y < 3))
-            return GetAutohidePositionMin ();
+      
+       // Be evil, but safe: position based == removing all existing time-based autohide
+       _times[TIME_AUTOHIDE].tv_sec = 0;
+       _times[TIME_AUTOHIDE].tv_nsec = 0;
         
        /* 
         * most of the mouse movement should be done by the inferior part
@@ -674,23 +674,22 @@
         */
                 
         float _max_size_on_position;
-        float position_on_border = _trigger_mouse_position.x * _trigger_height / _trigger_mouse_position.y;
+        float position_on_border = _bfb_mouse_position.x * _bfb_height / _bfb_mouse_position.y;
         
-        if (position_on_border < _trigger_width)
-            _max_size_on_position = pow(pow(position_on_border, 2) + pow(_trigger_height, 2), 0.5);
+        if (position_on_border < _bfb_width)
+            _max_size_on_position = pow(pow(position_on_border, 2) + pow(_bfb_height, 2), 0.5);
         else
         {
-            position_on_border = _trigger_mouse_position.y * _trigger_width / _trigger_mouse_position.x;
-            _max_size_on_position = pow(pow(position_on_border, 2) + pow(_trigger_width, 2), 0.5);
+            position_on_border = _bfb_mouse_position.y * _bfb_width / _bfb_mouse_position.x;
+            _max_size_on_position = pow(pow(position_on_border, 2) + pow(_bfb_width, 2), 0.5);
         }
         
         float _position_min = GetAutohidePositionMin ();
-        return pow(pow(_trigger_mouse_position.x, 2) + pow(_trigger_mouse_position.y, 2), 0.5) / _max_size_on_position * (GetAutohidePositionMax () - _position_min) + _position_min;
+        return pow(pow(_bfb_mouse_position.x, 2) + pow(_bfb_mouse_position.y, 2), 0.5) / _max_size_on_position * (GetAutohidePositionMax () - _position_min) + _position_min;
     }
-    
-    // time-based progress (full scale or finish the TRIGGER_AUTOHIDE_MIN -> 0.00f on bfb)
     else
     {
+        // time-based progress (full scale or finish the TRIGGER_AUTOHIDE_MIN -> 0.00f on bfb)
         float animation_progress;
         animation_progress = CLAMP ((float) (TimeDelta (&current, &_times[TIME_AUTOHIDE])) / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
         if (_hidden)
@@ -795,11 +794,9 @@
     if (TimeDelta (&current, &_times[TIME_DRAG_END]) < ANIM_DURATION_LONG)
         return true;
 
-    // hide animation (time or position)
+    // hide animation (time only), position is trigger manually on the bfb
     if (TimeDelta (&current, &_times[TIME_AUTOHIDE]) < ANIM_DURATION_SHORT)
         return true;
-    if (_mouse_inside_trigger && !_mouseover_launcher_locked)
-        return true;
     
     // collapse animation on DND out of launcher space
     if (TimeDelta (&current, &_times[TIME_DRAG_THRESHOLD]) < ANIM_DURATION_SHORT)
@@ -837,7 +834,7 @@
     timer->tv_sec = current.tv_sec;
     timer->tv_nsec = current.tv_nsec;
 }
-/* Min is when you lock the trigger */
+/* Min is when you are on the trigger */
 float Launcher::GetAutohidePositionMin ()
 {
     if (_autohide_animation == SLIDE_ONLY)
@@ -845,7 +842,7 @@
     else
         return 0.25f;
 }
-/* Max is the initial state */
+/* Max is the initial state over the bfb */
 float Launcher::GetAutohidePositionMax ()
 {
     if (_autohide_animation == SLIDE_ONLY)
@@ -1287,28 +1284,16 @@
     *launcher_alpha = 1.0f; 
     if (_hidemode != LAUNCHER_HIDE_NEVER)
     {
+        
         float autohide_progress = AutohideProgress (current);
-
         if (_autohide_animation == FADE_ONLY
-            || (_autohide_animation == FADE_SLIDE && _mouse_inside_trigger))
+            || (_autohide_animation == FADE_SLIDE && _hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_BFB)))
             *launcher_alpha = 1.0f - autohide_progress;
         else
         {
             if (autohide_progress > 0.0f)
                 autohide_offset -= geo.width * autohide_progress;
         }
-        /* _mouse_inside_trigger is particular because we don't change _hidden state
-        * as we can go back and for. We have to lock the launcher manually changing
-        * the _hidden state then
-        */
-        float _position_min = GetAutohidePositionMin ();
-        if (autohide_progress == _position_min && _mouse_inside_trigger && !_mouseover_launcher_locked)
-        {
-            ForceHiddenState (false); // lock the launcher
-            _times[TIME_AUTOHIDE] = current;
-            SetTimeBack (&_times[TIME_AUTOHIDE], ANIM_DURATION_SHORT * _position_min);
-            SetTimeStruct (&_times[TIME_AUTOHIDE], &_times[TIME_AUTOHIDE], ANIM_DURATION_SHORT); // finish the animation 
-        }
     }
     
     float drag_hide_progress = DragHideProgress (current);
@@ -1317,10 +1302,7 @@
         autohide_offset -= geo.width * 0.25f * drag_hide_progress;
         
         if (drag_hide_progress >= 1.0f)
-        {
-          _hide_on_drag_hover = true;
-          EnsureHiddenState ();
-        }
+          _hide_machine->SetQuirk (LauncherHideMachine::DND_PUSHED_OFF, true);
     }
 
     // Inform the painter where to paint the box
@@ -1387,62 +1369,74 @@
 
 void Launcher::StartKeyShowLauncher ()
 {
-    bool was_hidden = _hidden;
-    
-    _super_show_launcher = true;
+    _hide_machine->SetQuirk (LauncherHideMachine::TRIGGER_BUTTON_DOWN, true);
+    _hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);
     QueueDraw ();
     SetTimeStruct (&_times[TIME_TAP_SUPER], NULL, SUPER_TAP_DURATION);
     if (_redraw_handle > 0)
       g_source_remove (_redraw_handle);
     _redraw_handle = g_timeout_add (SUPER_TAP_DURATION, &Launcher::DrawLauncherTimeout, this);
-    EnsureHiddenState ();
-    
-    // don't lock on mouseover state to avoid locking it the pointer was already there but not moved
-    if (was_hidden)
-      _mouseover_launcher_locked = false;
 }
 
 void Launcher::EndKeyShowLauncher ()
 {
-
-    _super_show_launcher = false;
+    
+    _hide_machine->SetQuirk (LauncherHideMachine::TRIGGER_BUTTON_DOWN, false);
     QueueDraw ();
 
     // it's a tap on super
     if (TapOnSuper ())
       ubus_server_send_message (ubus_server_get_default (), UBUS_DASH_EXTERNAL_ACTIVATION, NULL);      
-      
-    SetupAutohideTimer ();
 }
 
 void Launcher::OnPlaceViewShown (GVariant *data, void *val)
 {
     Launcher *self = (Launcher*)val;
-    self->_placeview_show_launcher = true;
-    self->EnsureHiddenState ();
+    self->_hide_machine->SetQuirk (LauncherHideMachine::PLACES_VISIBLE, true);
+    
+    // hack around issue in nux where leave events dont always come after a grab
+    self->_hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_BFB, false);
 }
 
 void Launcher::OnPlaceViewHidden (GVariant *data, void *val)
 {
     Launcher *self = (Launcher*)val;
-    self->_placeview_show_launcher = false;
-    self->EnsureHiddenState ();
+    self->_hide_machine->SetQuirk (LauncherHideMachine::PLACES_VISIBLE, false);
 }
 
-void Launcher::OnTriggerUpdate (GVariant *data, gpointer user_data)
+void Launcher::OnBFBUpdate (GVariant *data, gpointer user_data)
 {
   gchar        *prop_key;
   GVariant     *prop_value;
   GVariantIter *prop_iter;
-  int x, y, trigger_width, trigger_height;
+  int x, y, bfb_width, bfb_height;
 
   Launcher *self = (Launcher*)user_data;
   
-  g_variant_get (data, "(iiiia{sv})", &x, &y, &trigger_width, &trigger_height, &prop_iter);
-  self->_trigger_mouse_position = nux::Point2 (x, y);
-  
-  self->_trigger_width = trigger_width;
-  self->_trigger_height = trigger_height;
+  g_variant_get (data, "(iiiia{sv})", &x, &y, &bfb_width, &bfb_height, &prop_iter);
+  self->_bfb_mouse_position = nux::Point2 (x, y);
+  
+  bool inside_trigger_area = (pow (x, 2) + pow (y, 2) < TRIGGER_SQR_RADIUS);
+  /*
+   * if we are currently hidden and we are over the trigger, prepare the change
+   * from a position-based move to a time-based one
+   * Fake that we were currently hiding with a corresponding position of GetAutohidePositionMin ()
+   * translated time-based so that we pick from the current position
+   */
+  if (inside_trigger_area && self->_hidden) {
+      self->_hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);
+
+      struct timespec current;
+      clock_gettime (CLOCK_MONOTONIC, &current);
+      self->_times[TIME_AUTOHIDE] = current;
+      SetTimeBack (&(self->_times[TIME_AUTOHIDE]), ANIM_DURATION_SHORT * (1.0f - self->GetAutohidePositionMin ()));
+      SetTimeStruct (&(self->_times[TIME_AUTOHIDE]), &(self->_times[TIME_AUTOHIDE]), ANIM_DURATION_SHORT);
+      self->_hide_machine->SetQuirk (LauncherHideMachine::MOUSE_MOVE_POST_REVEAL, true);
+  }
+  self->_hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_TRIGGER, inside_trigger_area);
+  
+  self->_bfb_width = bfb_width;
+  self->_bfb_height = bfb_height;
     
   g_return_if_fail (prop_iter != NULL);
 
@@ -1450,49 +1444,34 @@
   {
     if (g_str_equal ("hovered", prop_key))
     {
-      self->_mouse_inside_trigger = g_variant_get_boolean (prop_value);
-      if (self->_mouse_inside_trigger)
-        self->_hide_on_drag_hover = false;
-      self->EnsureHiddenState ();
+      self->_hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_BFB, g_variant_get_boolean (prop_value));
+
       self->EnsureHoverState ();
       self->EnsureScrollTimer ();    
     }
   }
+  
+  self->EnsureAnimation ();
 }
 
 void Launcher::OnActionDone (GVariant *data, void *val)
 {
-    Launcher *self = (Launcher*)val;
-    self->_mouseover_launcher_locked = false;
-    self->SetupAutohideTimer ();
-}
-
-void Launcher::ForceHiddenState (bool hidden)
-{
-    // force hidden state skipping the animation
-    SetHidden (hidden);
-    _times[TIME_AUTOHIDE].tv_sec = 0;
-    _times[TIME_AUTOHIDE].tv_nsec = 0;
+  Launcher *self = (Launcher*)val;
+  self->_hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, true);
 }
 
 void Launcher::SetHidden (bool hidden)
 {
     if (hidden == _hidden)
         return;
-        
-    // auto lock/unlock the launcher depending on the state switch
-    if (hidden)
-    {
-        _mouseover_launcher_locked = false;
-        // RecvMouseLeave isn't receive if the launcher is hiding while we have the mouse on it
-        // (like, click on a icon, wait the timeout time without moving the mouse, then the launcher hide)
-        if (_mouse_inside_launcher)
-          RecvMouseLeave(-1, -1, 0, 0);
-    }
-    else
-        _mouseover_launcher_locked = true;
 
     _hidden = hidden;
+    _hide_machine->SetQuirk (LauncherHideMachine::LAUNCHER_HIDDEN, hidden);
+    _hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);
+    _hide_machine->SetQuirk (LauncherHideMachine::MOUSE_MOVE_POST_REVEAL, false);
+    _postreveal_mousemove_delta_x = 0;
+    _postreveal_mousemove_delta_y = 0;
+
     SetTimeStruct (&_times[TIME_AUTOHIDE], &_times[TIME_AUTOHIDE], ANIM_DURATION_SHORT);
 
     _parent->EnableInputWindow(!hidden, "launcher", false, false);
@@ -1503,15 +1482,6 @@
     EnsureAnimation ();
 }
 
-gboolean Launcher::OnAutohideTimeout (gpointer data)
-{
-    Launcher *self = (Launcher*) data;
-
-    self->_autohide_handle = 0;
-    self->EnsureHiddenState ();
-    return false;
-}
-
 int
 Launcher::GetMouseX ()
 {
@@ -1532,40 +1502,6 @@
     return false;    
 }
 
-void
-Launcher::EnableHiddenStateCheck (bool enabled)
-{
-  _hidden_state_check = enabled;
-}
-
-void
-Launcher::EnsureHiddenState ()
-{
-  
-  // Ensure that the hidden state is relevant
-  // /!\ Only use that for a transitionning state (like viewport switch)
-  if (!_hidden_state_check)
-    return;
-  
-  // compiler should optimize this, we do this for readability
-  bool mouse_over_launcher = _mouseover_launcher_locked && (_mouse_inside_trigger || _mouse_inside_launcher);
-  
-  bool required_for_external_purpose = _super_show_launcher || _placeview_show_launcher || _navmod_show_launcher ||
-                                       QuicklistManager::Default ()->Current() || PluginAdapter::Default ()->IsScaleActive ();
-                                       
-  bool in_must_be_open_mode = GetActionState () != ACTION_NONE || _dnd_window_is_mapped;
-  
-  bool must_be_hidden = _hide_on_drag_hover && _hidemode != LAUNCHER_HIDE_NEVER;
-  
-  bool autohide_handle_hold = _autohide_handle && !_hidden;
-  
-  if (must_be_hidden || (!mouse_over_launcher && !required_for_external_purpose && 
-                         !in_must_be_open_mode && _window_over_launcher && !autohide_handle_hold))
-    SetHidden (true);
-  else
-    SetHidden (false);
-}
-
 bool
 Launcher::CheckIntersectWindow (CompWindow *window)
 {
@@ -1583,31 +1519,44 @@
 }
 
 void
+Launcher::EnableCheckWindowOverLauncher (gboolean enabled)
+{
+    _check_window_over_launcher = enabled;
+}
+
+void
 Launcher::CheckWindowOverLauncher ()
 {
   CompWindowList window_list = _screen->windows ();
   CompWindowList::iterator it;
   CompWindow *window = NULL;
 
-  if (_hidemode == LAUNCHER_HIDE_DODGE_ACTIVE_WINDOW)
+  bool any = false;
+  bool active = false;
+  
+  // state has no mean right now, the check will be done again later
+  if (!_check_window_over_launcher)
+    return;
+
+  window = _screen->findWindow (_screen->activeWindow ());
+  if (CheckIntersectWindow (window))
   {
-    window = _screen->findWindow (_screen->activeWindow ());
-    if (!CheckIntersectWindow (window))
-      window = NULL;
+    any = true;
+    active = true;
   }
   else
   {
     for (it = window_list.begin (); it != window_list.end (); it++)
     {
-      if (CheckIntersectWindow (*it)) {
-        window = *it;
+      if (CheckIntersectWindow (*it)) 
+      {
+        any = true;
         break;
       }
     }
   }
-
-  _window_over_launcher = (window != NULL);
-  EnsureHiddenState ();
+  _hide_machine->SetQuirk (LauncherHideMachine::ANY_WINDOW_UNDER, any);
+  _hide_machine->SetQuirk (LauncherHideMachine::ACTIVE_WINDOW_UNDER, active);
 }
 
 gboolean
@@ -1622,14 +1571,13 @@
   
   if (drag_owner)
   {
-    self->_dnd_window_is_mapped = true;
+    self->_hide_machine->SetQuirk (LauncherHideMachine::EXTERNAL_DND_ACTIVE, true);
   }
   else
   {
-    self->_hide_on_drag_hover = false;
-    self->_dnd_window_is_mapped = false;
+    self->_hide_machine->SetQuirk (LauncherHideMachine::EXTERNAL_DND_ACTIVE, false);
+    self->_hide_machine->SetQuirk (LauncherHideMachine::DND_PUSHED_OFF, false);
   }
-  self->EnsureHiddenState ();
 
   return false;
 }
@@ -1658,27 +1606,14 @@
 Launcher::OnWindowMaybeIntellihide (guint32 xid)
 {
   if (_hidemode != LAUNCHER_HIDE_NEVER)
-  {
-    if (_hidemode == LAUNCHER_HIDE_AUTOHIDE)
-    {
-      _window_over_launcher = true;
-      EnsureHiddenState ();
-    }
-    else
-    {
-      CheckWindowOverLauncher ();
-    }
-  }
+    CheckWindowOverLauncher ();
 }
 
-void Launcher::SetupAutohideTimer ()
+void
+Launcher::OnPluginStateChanged ()
 {
-  if (_hidemode != LAUNCHER_HIDE_NEVER)
-  {
-    if (_autohide_handle > 0)
-      g_source_remove (_autohide_handle);
-    _autohide_handle = g_timeout_add (1000, &Launcher::OnAutohideTimeout, this);
-  }
+  _hide_machine->SetQuirk (LauncherHideMachine::EXPO_ACTIVE, PluginAdapter::Default ()->IsExpoActive ());
+  _hide_machine->SetQuirk (LauncherHideMachine::SCALE_ACTIVE, PluginAdapter::Default ()->IsScaleActive ());
 }
 
 Launcher::LauncherHideMode Launcher::GetHideMode ()
@@ -1717,6 +1652,7 @@
   }
 
   _hidemode = hidemode;
+  _hide_machine->SetMode ((LauncherHideMachine::HideMode) hidemode);
   EnsureAnimation ();
 }
 
@@ -1793,8 +1729,8 @@
     return;
     
   _launcher_action_state = actionstate;
-
-  if (_navmod_show_launcher)
+  
+  if (_hide_machine->GetQuirk (LauncherHideMachine::KEY_NAV_ACTIVE))
     exitKeyNavMode ();
 }
 
@@ -1807,7 +1743,7 @@
 void
 Launcher::EnsureHoverState ()
 {
-  if (_mouse_inside_launcher || _mouse_inside_trigger || 
+  if (_hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER) || _hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_BFB) || 
       QuicklistManager::Default ()->Current() || GetActionState () != ACTION_NONE)
   {
     SetHover ();
@@ -1837,23 +1773,22 @@
 
   _hovered = false;
   SetTimeStruct (&_times[TIME_LEAVE], &_times[TIME_ENTER], ANIM_DURATION);
-  SetupAutohideTimer ();
   EnsureAnimation ();
 }
 
 bool Launcher::MouseOverTopScrollArea ()
 {
   if (GetActionState () == ACTION_NONE)
-    return _mouse_inside_trigger;
+    return _hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_BFB);
   
   return _mouse_position.y < 0;
 }
 
 bool Launcher::MouseOverTopScrollExtrema ()
 {
-  // since we are not dragging the trigger will pick up events
+  // since we are not dragging the bfb will pick up events
   if (GetActionState () == ACTION_NONE)
-    return _trigger_mouse_position.y == 0;
+    return _bfb_mouse_position.y == 0;
     
   return _mouse_position.y == 0 - _parent->GetGeometry ().y;
 }
@@ -2381,7 +2316,7 @@
                     geo);
 
   /* draw superkey-shortcut label */ 
-  if (_super_show_launcher && !TapOnSuper ())
+  if (_hide_machine->GetQuirk (LauncherHideMachine::TRIGGER_BUTTON_DOWN) && !TapOnSuper ())
   {
     guint64 shortcut = arg.icon->GetShortcut ();
 
@@ -2566,7 +2501,8 @@
 {
   if (!icon)
     return;
-    
+  
+  _hide_machine->SetQuirk (LauncherHideMachine::INTERNAL_DND_ACTIVE, true);
   _drag_icon = icon;
 
   if (_drag_window)
@@ -2596,6 +2532,7 @@
     SetTimeStruct (&_times[TIME_DRAG_THRESHOLD], &_times[TIME_DRAG_THRESHOLD], ANIM_DURATION_SHORT);
   
   _render_drag_window = false;
+  _hide_machine->SetQuirk (LauncherHideMachine::INTERNAL_DND_ACTIVE, false);
 }
 
 void Launcher::UpdateDragWindowPosition (int x, int y)
@@ -2632,7 +2569,7 @@
 
 void Launcher::RecvMouseDownOutsideArea (int x, int y, unsigned long button_flags, unsigned long key_flags)
 {
-  if (_navmod_show_launcher)
+  if (_hide_machine->GetQuirk (LauncherHideMachine::KEY_NAV_ACTIVE))
     exitKeyNavMode ();
 }
 
@@ -2648,10 +2585,12 @@
   }
   
   MouseUpLogic (x, y, button_flags, key_flags);
-
+  
   if (GetActionState () == ACTION_DRAG_ICON)
     EndIconDrag ();
-    
+
+  if (GetActionState () == ACTION_DRAG_LAUNCHER)   
+    _hide_machine->SetQuirk (LauncherHideMachine::VERTICAL_SLIDE_ACTIVE, false);
   SetActionState (ACTION_NONE);
   _dnd_delta_x = 0;
   _dnd_delta_y = 0;
@@ -2667,8 +2606,8 @@
   _dnd_delta_y += dy;
   _dnd_delta_x += dx;
   
-  if (nux::Abs (_dnd_delta_y) < 15 &&
-      nux::Abs (_dnd_delta_x) < 15 && 
+  if (nux::Abs (_dnd_delta_y) < MOUSE_DEADZONE &&
+      nux::Abs (_dnd_delta_x) < MOUSE_DEADZONE && 
       GetActionState () == ACTION_NONE)
       return;
 
@@ -2685,6 +2624,7 @@
     {
       _launcher_drag_delta += _dnd_delta_y;
       SetActionState (ACTION_DRAG_LAUNCHER);
+      _hide_machine->SetQuirk (LauncherHideMachine::VERTICAL_SLIDE_ACTIVE, true);
     }
     else
     {
@@ -2705,8 +2645,13 @@
 
 void Launcher::RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags)
 {
+  
+  // FIXME: Ugly workaround for nux sending mouse enter signal on super key release or keynav enter
+  if (x < 0)
+    return;
+  
   SetMousePosition (x, y);
-  _mouse_inside_launcher = true;
+  _hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER, true);
 
   EnsureHoverState ();
 
@@ -2716,21 +2661,17 @@
 
 void Launcher::RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)
 {
+
+  // FIXME: Ugly workaround for nux sending mouse leave signal on super key release or keynav exit
+  if (x < 0)
+    return;
+
   SetMousePosition (x, y);
-  _mouse_inside_launcher = false;
-      
+  _hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER, false);
+        
   if (GetActionState () == ACTION_NONE)
       EnsureHoverState ();
 
-  // exit immediatly on action and mouse leaving the launcher (avoid loop when called manually)
-  if (!_mouseover_launcher_locked && (x != -1) && (y != -1))
-  {
-    if (_autohide_handle > 0)
-      g_source_remove (_autohide_handle);
-    _autohide_handle = 0;
-    EnsureHiddenState ();
-  }
-
   EventLogic ();
   EnsureAnimation ();
 }
@@ -2738,6 +2679,16 @@
 void Launcher::RecvMouseMove(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
 {
   SetMousePosition (x, y);
+    
+  _postreveal_mousemove_delta_x += dx;
+  _postreveal_mousemove_delta_y += dy;
+  
+  // check the state before changing it to avoid uneeded hide calls
+  if (!_hide_machine->GetQuirk (LauncherHideMachine::MOUSE_MOVE_POST_REVEAL) &&
+      (nux::Abs (_postreveal_mousemove_delta_x) > MOUSE_DEADZONE ||
+      nux::Abs (_postreveal_mousemove_delta_y) > MOUSE_DEADZONE))
+    _hide_machine->SetQuirk (LauncherHideMachine::MOUSE_MOVE_POST_REVEAL, true);
+  
 
   // Every time the mouse moves, we check if it is inside an icon...
   EventLogic ();
@@ -2767,7 +2718,7 @@
                                      unsigned long key_code,
                                      unsigned long key_state)
 {
-  if (!_super_show_launcher)
+  if (!_hide_machine->GetQuirk (LauncherHideMachine::TRIGGER_BUTTON_DOWN))
     return false;
 
   LauncherModel::iterator it;
@@ -2817,7 +2768,7 @@
         if (it != (LauncherModel::iterator)NULL)
           _current_icon_index = temp_current_icon_index;      
       }
-      NeedRedraw ();
+      EnsureAnimation ();
       selection_change.emit ();
     break;
 
@@ -2836,7 +2787,7 @@
         if (it != (LauncherModel::iterator)NULL)
           _current_icon_index = temp_current_icon_index;     
 
-        NeedRedraw ();
+        EnsureAnimation ();
         selection_change.emit ();
       }
     break;
@@ -2891,6 +2842,7 @@
 
 void Launcher::RecvQuicklistOpened (QuicklistView *quicklist)
 {
+  _hide_machine->SetQuirk (LauncherHideMachine::QUICKLIST_OPEN, true);
   EventLogic ();
   EnsureHoverState ();
   EnsureAnimation ();
@@ -2898,7 +2850,7 @@
 
 void Launcher::RecvQuicklistClosed (QuicklistView *quicklist)
 {
-  SetupAutohideTimer ();
+  _hide_machine->SetQuirk (LauncherHideMachine::QUICKLIST_OPEN, false);
 
   EventLogic ();
   EnsureHoverState ();
@@ -2912,14 +2864,9 @@
     return;
 
   LauncherIcon* launcher_icon = 0;
-  bool should_lock_launcher = false;
 
-  if (_mouse_inside_launcher) {
+  if (_hide_machine->GetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER)) {
     launcher_icon = MouseIconIntersection (_mouse_position.x, _mouse_position.y);
-    // indicate if the mouse should relock the launcher or not (it doesn't explicitely lock the launcher
-    // when it's entering the launcher. This is for the case: Super reveals the launcher, mouse doesn't move)
-    if (_icon_under_mouse && !_hidden)
-      should_lock_launcher = true;
   }  
   
 
@@ -2935,9 +2882,8 @@
     launcher_icon->MouseEnter.emit ();
     launcher_icon->_mouse_inside = true;
     _icon_under_mouse = launcher_icon;
-    // reset trigger only when in right context
-    if (should_lock_launcher)
-      _mouseover_launcher_locked = true;
+    
+    _hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);
   }
 }
 
@@ -2945,6 +2891,8 @@
 {
   LauncherIcon* launcher_icon = 0;
   launcher_icon = MouseIconIntersection (_mouse_position.x, _mouse_position.y);
+  
+  _hide_machine->SetQuirk (LauncherHideMachine::LAST_ACTION_ACTIVATE, false);
 
   if (launcher_icon)
   {
@@ -3449,7 +3397,7 @@
 void 
 Launcher::ProcessDndLeave ()
 {
-  _mouse_inside_launcher = false;
+  _hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER, false);
   _drag_edge_touching = false;
 
   SetActionState (ACTION_NONE);
@@ -3549,7 +3497,7 @@
 
     // only set hover once we know our first x/y
     SetActionState (ACTION_DRAG_EXTERNAL);
-    _mouse_inside_launcher = true;
+    _hide_machine->SetQuirk (LauncherHideMachine::MOUSE_OVER_LAUNCHER, true);
     
     LauncherModel::iterator it;
     for (it = _model->begin (); it != _model->end () && !_steal_drag; it++)

=== modified file 'src/Launcher.h'
--- src/Launcher.h	2011-03-18 16:26:04 +0000
+++ src/Launcher.h	2011-03-21 19:14:32 +0000
@@ -30,6 +30,7 @@
 #include "Introspectable.h"
 #include "LauncherIcon.h"
 #include "LauncherDragWindow.h"
+#include "LauncherHideMachine.h"
 #include "NuxGraphics/IOpenGLAsmShader.h"
 #include "Nux/TimerProc.h"
 #include "PluginAdapter.h"
@@ -157,7 +158,7 @@
   int GetMouseY ();
   
   void CheckWindowOverLauncher ();
-  void EnableHiddenStateCheck (bool enabled);
+  void EnableCheckWindowOverLauncher (gboolean enabled);
 
   sigc::signal<void, char *, LauncherIcon *> launcher_addrequest;
   sigc::signal<void> selection_change;
@@ -220,9 +221,10 @@
   void OnWindowMaybeIntellihide (guint32 xid);
   void OnWindowMapped (guint32 xid);
   void OnWindowUnmapped (guint32 xid);
-
+  
+  void OnPluginStateChanged ();
+  
   static gboolean AnimationTimeout (gpointer data);
-  static gboolean OnAutohideTimeout (gpointer data);
   static gboolean DrawLauncherTimeout (gpointer data);
   static gboolean StrutHack (gpointer data);
   static gboolean MoveFocusToKeyNavModeTimeout (gpointer data);
@@ -241,10 +243,8 @@
   LauncherActionState GetActionState(); 
 
   void EnsureHoverState ();
-  void EnsureHiddenState ();
   void EnsureAnimation    ();
   void EnsureScrollTimer ();
-  void SetupAutohideTimer ();
   
   bool MouseOverTopScrollArea ();
   bool MouseOverTopScrollExtrema ();
@@ -277,7 +277,6 @@
 
   void SetHover         ();
   void UnsetHover       ();
-  void ForceHiddenState (bool hidden);
   void SetHidden        (bool hidden);
 
   void  SetDndDelta (float x, float y, nux::Geometry geo, struct timespec const &current);
@@ -309,7 +308,7 @@
   static void OnPlaceViewHidden (GVariant *data, void *val);
   static void OnPlaceViewShown (GVariant *data, void *val);
   
-  static void OnTriggerUpdate (GVariant *data, gpointer user_data);
+  static void OnBFBUpdate (GVariant *data, gpointer user_data);
 
   static void OnActionDone (GVariant *data, void *val);
 
@@ -396,16 +395,8 @@
   bool  _hovered;
   bool  _floating;
   bool  _hidden;
-  bool  _hidden_state_check;
-  bool  _mouse_inside_launcher;
-  bool  _mouse_inside_trigger;
-  bool  _mouseover_launcher_locked;
-  bool  _super_show_launcher;
-  bool  _navmod_show_launcher;
-  bool  _placeview_show_launcher;
-  bool  _window_over_launcher;
-  bool  _hide_on_drag_hover;
   bool  _render_drag_window;
+  bool  _check_window_over_launcher;
   
   BacklightMode _backlight_mode;
 
@@ -433,13 +424,14 @@
   int _icon_glow_size;
   int _dnd_delta_y;
   int _dnd_delta_x;
+  int _postreveal_mousemove_delta_x;
+  int _postreveal_mousemove_delta_y;
   int _launcher_drag_delta;
-  int _dnd_security;
   int _enter_y;
   int _last_button_press;
   
-  int _trigger_width;
-  int _trigger_height;
+  int _bfb_width;
+  int _bfb_height;
 
   nux::BaseTexture* _icon_bkg_texture;
   nux::BaseTexture* _icon_shine_texture;
@@ -461,23 +453,22 @@
   nux::IntrusiveSP<nux::IOpenGLBaseTexture> _offscreen_drag_texture;
   nux::IntrusiveSP<nux::IOpenGLBaseTexture> _offscreen_progress_texture;
 
-  guint _autohide_handle;
   guint _autoscroll_handle;
   guint _focus_keynav_handle;
   guint _redraw_handle;
   guint _start_dragicon_handle;
 
   nux::Point2   _mouse_position;
-  nux::Point2   _trigger_mouse_position;
+  nux::Point2   _bfb_mouse_position;
   nux::IntrusiveSP<nux::IOpenGLShaderProgram>    _shader_program_uv_persp_correction;
   nux::IntrusiveSP<nux::IOpenGLAsmShaderProgram> _AsmShaderProg;
   nux::AbstractPaintLayer* m_BackgroundLayer;
   nux::BaseWindow* _parent;
   LauncherModel* _model;
   LauncherDragWindow* _drag_window;
+  LauncherHideMachine *_hide_machine;
   CompScreen* _screen;
   
-  bool              _dnd_window_is_mapped;
   std::list<char *> _drag_data;
   nux::DndAction    _drag_action;
   bool              _data_checked;

=== added file 'src/LauncherHideMachine.cpp'
--- src/LauncherHideMachine.cpp	1970-01-01 00:00:00 +0000
+++ src/LauncherHideMachine.cpp	2011-03-21 19:14:32 +0000
@@ -0,0 +1,203 @@
+// -*- 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: Jason Smith <[e-mail]>
+ */
+ 
+#include "LauncherHideMachine.h"
+
+LauncherHideMachine::LauncherHideMachine ()
+{
+  _mode  = HIDE_NEVER;
+  _quirks = DEFAULT;
+  _should_hide = false;
+  
+  _hide_delay_handle = 0;
+  _hide_delay_timeout_length = 750;
+}
+
+LauncherHideMachine::~LauncherHideMachine ()
+{
+  if (_hide_delay_handle)
+  {
+    g_source_remove (_hide_delay_handle);
+    _hide_delay_handle = 0;
+  }
+}
+
+void
+LauncherHideMachine::SetShouldHide (bool value, bool skip_delay)
+{
+  if (_should_hide == value)
+    return;
+    
+  if (value && !skip_delay)
+  {
+    if (_hide_delay_handle)
+      g_source_remove (_hide_delay_handle);
+    
+    _hide_delay_handle = g_timeout_add (_hide_delay_timeout_length, &OnHideDelayTimeout, this);
+  }
+  else
+  {
+    _should_hide = value;
+    should_hide_changed.emit (value);
+  }
+}
+
+/* == Quick Quirk Reference : please keep up to date ==
+    LAUNCHER_HIDDEN        = 1 << 0, 1
+    MOUSE_OVER_LAUNCHER    = 1 << 1, 2
+    MOUSE_OVER_BFB         = 1 << 2, 4
+    MOUSE_OVER_TRIGGER     = 1 << 3, 8
+    QUICKLIST_OPEN         = 1 << 4, 16  #VISIBLE_REQUIRED
+    EXTERNAL_DND_ACTIVE    = 1 << 5, 32  #VISIBLE_REQUIRED
+    INTERNAL_DND_ACTIVE    = 1 << 6, 64  #VISIBLE_REQUIRED
+    TRIGGER_BUTTON_DOWN    = 1 << 7, 128 #VISIBLE_REQUIRED
+    ANY_WINDOW_UNDER       = 1 << 8, 256
+    ACTIVE_WINDOW_UNDER    = 1 << 9, 512
+    DND_PUSHED_OFF         = 1 << 10, 1024
+    MOUSE_MOVE_POST_REVEAL = 1 << 11, 2k
+    VERTICAL_SLIDE_ACTIVE  = 1 << 12, 4k  #VISIBLE_REQUIRED
+    KEY_NAV_ACTIVE         = 1 << 13, 8k  #VISIBLE_REQUIRED
+    PLACES_VISIBLE         = 1 << 14, 16k #VISIBLE_REQUIRED
+    LAST_ACTION_ACTIVATE   = 1 << 15, 32k
+    SCALE_ACTIVE           = 1 << 16, 64k  #VISIBLE_REQUIRED
+    EXPO_ACTIVE            = 1 << 17, 128k #VISIBLE_REQUIRED
+*/
+
+#define VISIBLE_REQUIRED (QUICKLIST_OPEN | EXTERNAL_DND_ACTIVE | \
+INTERNAL_DND_ACTIVE | TRIGGER_BUTTON_DOWN | VERTICAL_SLIDE_ACTIVE |\
+KEY_NAV_ACTIVE | PLACES_VISIBLE | SCALE_ACTIVE | EXPO_ACTIVE)
+
+void
+LauncherHideMachine::EnsureHideState (bool skip_delay)
+{
+  bool should_hide;
+  
+  if (_mode == HIDE_NEVER)
+  {
+    SetShouldHide (false, skip_delay);
+    return;
+  }
+  
+  do
+  {
+    // first we check the condition where external DND is active and the push off has happened
+    if (GetQuirk ((HideQuirk) (EXTERNAL_DND_ACTIVE | DND_PUSHED_OFF), false))
+    {
+      should_hide = true;
+      break;
+    }
+    
+    if (GetQuirk (LAST_ACTION_ACTIVATE))
+    {
+      should_hide = true;
+      break;
+    }
+    
+    HideQuirk _should_show_quirk;
+
+    if (GetQuirk (LAUNCHER_HIDDEN))
+      _should_show_quirk = (HideQuirk) (VISIBLE_REQUIRED | MOUSE_OVER_TRIGGER);
+    else {
+      _should_show_quirk = (HideQuirk) (VISIBLE_REQUIRED | MOUSE_OVER_BFB);
+      // mouse position over launcher is only taken into account if we move it after the revealing state
+      if (GetQuirk (MOUSE_MOVE_POST_REVEAL))
+        _should_show_quirk = (HideQuirk) (_should_show_quirk | MOUSE_OVER_LAUNCHER); 
+    }
+
+    if (GetQuirk (_should_show_quirk))
+    {
+      should_hide = false;
+      break;
+    }
+
+    if (_mode == AUTOHIDE)
+      should_hide = true;
+    else if (_mode == DODGE_WINDOWS)
+      should_hide = GetQuirk (ANY_WINDOW_UNDER);
+    else if (_mode == DODGE_ACTIVE_WINDOW)
+      should_hide = GetQuirk (ACTIVE_WINDOW_UNDER);
+
+  } while (false);
+  
+  SetShouldHide (should_hide, skip_delay);
+}
+
+void
+LauncherHideMachine::SetMode (LauncherHideMachine::HideMode mode)
+{
+  if (_mode == mode)
+    return;
+  
+  _mode = mode;
+  EnsureHideState (true);
+}
+
+LauncherHideMachine::HideMode
+LauncherHideMachine::GetMode ()
+{
+  return _mode;
+}
+
+#define SKIP_DELAY_QUIRK (EXTERNAL_DND_ACTIVE | DND_PUSHED_OFF | ACTIVE_WINDOW_UNDER | \
+ANY_WINDOW_UNDER | EXPO_ACTIVE | SCALE_ACTIVE)
+
+void
+LauncherHideMachine::SetQuirk (LauncherHideMachine::HideQuirk quirk, bool active)
+{
+  if (GetQuirk (quirk) == active)
+    return;
+  
+  if (active)
+    _quirks = (HideQuirk) (_quirks | quirk);
+  else
+    _quirks = (HideQuirk) (_quirks & ~quirk);
+  
+  // no skipping when last action was activate on general case
+  bool skip = quirk & SKIP_DELAY_QUIRK && !GetQuirk (LAST_ACTION_ACTIVATE);
+  
+  // but skip on last action if we were out of the launcher/bfb
+  if (GetQuirk (LAST_ACTION_ACTIVATE) && !active && (quirk & (MOUSE_OVER_LAUNCHER | MOUSE_OVER_BFB)))
+    skip = true;
+  
+  EnsureHideState (skip);
+}
+
+bool
+LauncherHideMachine::GetQuirk (LauncherHideMachine::HideQuirk quirk, bool allow_partial)
+{
+  if (allow_partial)
+    return _quirks & quirk;
+  return (_quirks & quirk) == quirk;
+}
+
+bool
+LauncherHideMachine::ShouldHide ()
+{
+  return _should_hide;
+}
+
+gboolean
+LauncherHideMachine::OnHideDelayTimeout (gpointer data)
+{
+  LauncherHideMachine *self = static_cast<LauncherHideMachine *> (data);
+  self->EnsureHideState (true);
+  
+  self->_hide_delay_handle = 0;
+  return false;
+}

=== added file 'src/LauncherHideMachine.h'
--- src/LauncherHideMachine.h	1970-01-01 00:00:00 +0000
+++ src/LauncherHideMachine.h	2011-03-21 19:14:32 +0000
@@ -0,0 +1,87 @@
+// -*- 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: Jason Smith <[e-mail]>
+ */
+
+#ifndef LAUNCHERHIDEMACHINE
+#define LAUNCHERHIDEMACHINE
+
+#include <sigc++/sigc++.h>
+#include <glib.h>
+
+class LauncherHideMachine : public sigc::trackable
+{
+  public:
+    typedef enum
+    {
+      HIDE_NEVER,
+      AUTOHIDE,
+      DODGE_WINDOWS,
+      DODGE_ACTIVE_WINDOW,
+    } HideMode;
+  
+    typedef enum
+    {
+      DEFAULT                = 0,
+      LAUNCHER_HIDDEN        = 1 << 0, 
+      MOUSE_OVER_LAUNCHER    = 1 << 1, 
+      MOUSE_OVER_BFB         = 1 << 2, 
+      MOUSE_OVER_TRIGGER     = 1 << 3, 
+      QUICKLIST_OPEN         = 1 << 4, 
+      EXTERNAL_DND_ACTIVE    = 1 << 5, 
+      INTERNAL_DND_ACTIVE    = 1 << 6, 
+      TRIGGER_BUTTON_DOWN    = 1 << 7, 
+      ANY_WINDOW_UNDER       = 1 << 8, 
+      ACTIVE_WINDOW_UNDER    = 1 << 9,
+      DND_PUSHED_OFF         = 1 << 10,
+      MOUSE_MOVE_POST_REVEAL = 1 << 11,
+      VERTICAL_SLIDE_ACTIVE  = 1 << 12, 
+      KEY_NAV_ACTIVE         = 1 << 13, 
+      PLACES_VISIBLE         = 1 << 14,
+      LAST_ACTION_ACTIVATE   = 1 << 15,
+      SCALE_ACTIVE           = 1 << 16,
+      EXPO_ACTIVE            = 1 << 17,
+    } HideQuirk;
+  
+    LauncherHideMachine ();
+    virtual ~LauncherHideMachine ();
+    
+    void     SetMode (HideMode mode);
+    HideMode GetMode ();
+    
+    void SetQuirk (HideQuirk quirk, bool active);
+    bool GetQuirk (HideQuirk quirk, bool allow_partial = true);
+    
+    bool ShouldHide ();
+    
+    sigc::signal<void, bool> should_hide_changed;
+    
+  private:
+    void EnsureHideState (bool skip_delay);
+    void SetShouldHide (bool value, bool skip_delay);
+
+    static gboolean OnHideDelayTimeout (gpointer data);
+  
+    bool      _should_hide;
+    HideQuirk _quirks;
+    HideMode  _mode;
+    unsigned int _hide_delay_timeout_length;
+    
+    guint _hide_delay_handle;
+};
+
+#endif

=== modified file 'src/PanelHomeButton.cpp'
--- src/PanelHomeButton.cpp	2011-03-10 14:42:25 +0000
+++ src/PanelHomeButton.cpp	2011-03-21 19:14:32 +0000
@@ -170,7 +170,7 @@
   
 
   UBusServer *ubus = ubus_server_get_default ();
-  ubus_server_send_message (ubus, UBUS_HOME_BUTTON_TRIGGER_UPDATE, g_variant_builder_end (&builder));
+  ubus_server_send_message (ubus, UBUS_HOME_BUTTON_BFB_UPDATE, g_variant_builder_end (&builder));
 }
 
 void 
@@ -190,7 +190,7 @@
   
 
   UBusServer *ubus = ubus_server_get_default ();
-  ubus_server_send_message (ubus, UBUS_HOME_BUTTON_TRIGGER_UPDATE, g_variant_builder_end (&builder));
+  ubus_server_send_message (ubus, UBUS_HOME_BUTTON_BFB_UPDATE, g_variant_builder_end (&builder));
 }
 
 void 
@@ -205,11 +205,12 @@
   g_variant_builder_add (&builder, "i", PANEL_HEIGHT);
   
   g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
+  g_variant_builder_add (&builder, "{sv}", "hovered", g_variant_new_boolean (true));
   g_variant_builder_close (&builder);
   
 
   UBusServer *ubus = ubus_server_get_default ();
-  ubus_server_send_message (ubus, UBUS_HOME_BUTTON_TRIGGER_UPDATE, g_variant_builder_end (&builder));
+  ubus_server_send_message (ubus, UBUS_HOME_BUTTON_BFB_UPDATE, g_variant_builder_end (&builder));
 }
 
 void

=== modified file 'src/PanelMenuView.cpp'
--- src/PanelMenuView.cpp	2011-03-17 09:41:28 +0000
+++ src/PanelMenuView.cpp	2011-03-21 19:14:32 +0000
@@ -181,8 +181,10 @@
 
   if (_is_maximized)
   {
-    ret = _window_buttons->ProcessEvent (ievent, ret, ProcessEventInfo);
-    ret = _panel_titlebar_grab_area->OnEvent (ievent, ret, ProcessEventInfo);
+    if (_window_buttons)
+      ret = _window_buttons->ProcessEvent (ievent, ret, ProcessEventInfo);
+    if (_panel_titlebar_grab_area)
+      ret = _panel_titlebar_grab_area->OnEvent (ievent, ret, ProcessEventInfo);
   }
 
   if (!_is_own_window)
@@ -702,7 +704,7 @@
 }
 
 void
-PanelMenuView::OnSpreadInitiate (std::list <guint32> &windows)
+PanelMenuView::OnSpreadInitiate ()
 {
   /*foreach (guint32 &xid, windows)
   {
@@ -712,7 +714,7 @@
 }
 
 void
-PanelMenuView::OnSpreadTerminate (std::list <guint32> &windows)
+PanelMenuView::OnSpreadTerminate ()
 {
   /*foreach (guint32 &xid, windows)
   {

=== modified file 'src/PanelMenuView.h'
--- src/PanelMenuView.h	2011-03-17 09:41:28 +0000
+++ src/PanelMenuView.h	2011-03-21 19:14:32 +0000
@@ -67,8 +67,8 @@
   void OnActiveWindowChanged (BamfView *old_view, BamfView *new_view);
   void OnNameChanged (gchar* new_name, gchar* old_name);
 
-  void OnSpreadInitiate (std::list <guint32> &);
-  void OnSpreadTerminate (std::list <guint32> &);
+  void OnSpreadInitiate ();
+  void OnSpreadTerminate ();
   void OnWindowMinimized (guint32 xid);
   void OnWindowUnminimized (guint32 xid);
   void OnWindowUnmapped (guint32 xid);

=== modified file 'src/PlacesController.cpp'
--- src/PlacesController.cpp	2011-03-13 21:42:18 +0000
+++ src/PlacesController.cpp	2011-03-21 19:14:32 +0000
@@ -59,7 +59,6 @@
   _window->SinkReference ();
   _window->SetConfigureNotifyCallback(&PlacesController::WindowConfigureCallback, this);
   _window->ShowWindow(false);
-  _window->InputWindowEnableStruts(false);
   _window->SetOpacity (0.0f);
 
   _window->OnMouseDownOutsideArea.connect (sigc::mem_fun (this, &PlacesController::RecvMouseDownOutsideOfView));
@@ -118,9 +117,8 @@
   _window->ShowWindow (true, false);
   // Raise this window on top of all other BaseWindows
   _window->PushToFront ();
-  _window->EnableInputWindow (true, "places", false, true);
   _window->GrabPointer ();
-  //_window->GrabKeyboard ();
+  _window->GrabKeyboard ();
   _window->QueueDraw ();
   _window->CaptureMouseDownAnyWhereElse (true);
   
@@ -138,8 +136,7 @@
   _window->CaptureMouseDownAnyWhereElse (false);
   _window->ForceStopFocus (1, 1);
   _window->UnGrabPointer ();
-  //_window->UnGrabKeyboard ();
-  _window->EnableInputWindow (false);
+  _window->UnGrabKeyboard ();
   _visible = false;
   _fullscren_request = false;
 

=== modified file 'src/PlacesHomeView.cpp'
--- src/PlacesHomeView.cpp	2011-03-15 12:30:55 +0000
+++ src/PlacesHomeView.cpp	2011-03-21 19:14:32 +0000
@@ -64,6 +64,7 @@
     _place_section (0),
     _exec (NULL)
   {
+    SetDndEnabled (false, false);
   }
 
   ~Shortcut ()

=== modified file 'src/PlacesTile.cpp'
--- src/PlacesTile.cpp	2011-03-10 13:03:21 +0000
+++ src/PlacesTile.cpp	2011-03-21 19:14:32 +0000
@@ -323,7 +323,8 @@
 void
 PlacesTile::RecvMouseClick (int x, int y, unsigned long button_flags, unsigned long key_flags)
 {
-  sigClick.emit (this);
+  if (nux::GetEventButton (button_flags) == 1)
+    sigClick.emit (this);
   QueueDraw ();
 }
 

=== modified file 'src/PluginAdapter.cpp'
--- src/PluginAdapter.cpp	2011-02-10 21:06:26 +0000
+++ src/PluginAdapter.cpp	2011-03-21 19:14:32 +0000
@@ -46,6 +46,8 @@
     m_ExpoActionList (0),
     m_ScaleActionList (0)
 {
+  _spread_state = false;
+  _expo_state = false;
 }
 
 PluginAdapter::~PluginAdapter()
@@ -56,13 +58,33 @@
 void
 PluginAdapter::OnScreenGrabbed ()
 {
+  if (!_spread_state && screen->grabExist ("scale"))
+  {
+    _spread_state = true;
+    initiate_spread.emit ();
+  }
+  
+  if (!_expo_state && screen->grabExist ("expo"))
+  {
+    _expo_state = true;
+    initiate_expo.emit ();
+  }
 }
 
 void
 PluginAdapter::OnScreenUngrabbed ()
 {
-  if (m_SpreadedWindows.size () && !screen->grabExist ("scale"))
-    terminate_spread.emit (m_SpreadedWindows);
+  if (_spread_state && !screen->grabExist ("scale"))
+  {
+    _spread_state = false;
+    terminate_spread.emit ();
+  }
+  
+  if (_expo_state && !screen->grabExist ("expo"))
+  {
+    _expo_state = false;
+    terminate_expo.emit ();
+  }
 }
 
 void
@@ -258,7 +280,6 @@
     }
   }
 
-  initiate_spread.emit (xids);
   m_ScaleActionList.InitiateAll (argument, state);
 }
 
@@ -267,7 +288,6 @@
 {
   CompOption::Vector argument (0);
 
-  terminate_spread.emit (m_SpreadedWindows);
   m_SpreadedWindows.clear ();
   m_ScaleActionList.TerminateAll (argument);
 }
@@ -278,6 +298,12 @@
   return m_Screen->grabExist ("scale");
 }
 
+bool
+PluginAdapter::IsExpoActive ()
+{
+  return m_Screen->grabExist ("expo");
+}
+
 void 
 PluginAdapter::InitiateExpo ()
 {

=== modified file 'src/PluginAdapter.h'
--- src/PluginAdapter.h	2011-02-10 21:06:26 +0000
+++ src/PluginAdapter.h	2011-03-21 19:14:32 +0000
@@ -69,6 +69,7 @@
     bool IsScaleActive ();
     
     void InitiateExpo ();
+    bool IsExpoActive ();
 
     void Notify (CompWindow *window, CompWindowNotify notify);
     void NotifyMoved (CompWindow *window, int x, int y);
@@ -94,6 +95,9 @@
     MultiActionList m_ScaleActionList;
     std::list <guint32> m_SpreadedWindows;
     
+    bool _spread_state;
+    bool _expo_state;
+    
     static PluginAdapter *_default;
 };
 

=== modified file 'src/UBusMessages.h'
--- src/UBusMessages.h	2011-03-01 09:22:43 +0000
+++ src/UBusMessages.h	2011-03-21 19:14:32 +0000
@@ -23,7 +23,7 @@
 // keep ordered
 
 #define UBUS_DASH_EXTERNAL_ACTIVATION   "DASH_EXTERNAL_ACTIVATION"
-#define UBUS_HOME_BUTTON_TRIGGER_UPDATE "PANEL_HOME_BUTTON_TRIGGER_UPDATE"
+#define UBUS_HOME_BUTTON_BFB_UPDATE "PANEL_HOME_BUTTON_BFB_UPDATE"
 
 // When other parts of Unity want to close the place view
 #define UBUS_PLACE_VIEW_CLOSE_REQUEST "PLACE_VIEW_CLOSE_REQUEST"

=== modified file 'src/WindowManager.h'
--- src/WindowManager.h	2011-02-09 14:28:54 +0000
+++ src/WindowManager.h	2011-03-21 19:14:32 +0000
@@ -74,8 +74,12 @@
   sigc::signal<void, guint32> window_hidden;
   sigc::signal<void, guint32> window_resized;
   sigc::signal<void, guint32> window_moved;
-  sigc::signal<void, std::list<guint32> &> initiate_spread;
-  sigc::signal<void, std::list<guint32> &> terminate_spread;
+  
+  sigc::signal<void> initiate_spread;
+  sigc::signal<void> terminate_spread;
+
+  sigc::signal<void> initiate_expo;
+  sigc::signal<void> terminate_expo;
 
 private:
   Atom m_MoveResizeAtom;

=== modified file 'src/unityshell.cpp'
--- src/unityshell.cpp	2011-03-18 18:35:33 +0000
+++ src/unityshell.cpp	2011-03-21 19:14:32 +0000
@@ -201,6 +201,9 @@
         if (_key_nav_mode_requested)
           launcher->startKeyNavMode ();
         _key_nav_mode_requested = false;
+        if (_need_send_execute_command)
+          SendExecuteCommand ();
+        _need_send_execute_command = false;
       break;
     case KeyPress:
       KeySym key_sym;
@@ -225,19 +228,20 @@
                                 CompOption::Vector  &option)
 {
 
-  if (strcmp (event, "begin_viewport_switch") == 0)
-  {
-    launcher->EnableHiddenStateCheck (false);
-  }
-  if (strcmp (event, "end_viewport_switch") == 0)
+  /*
+   *  don't take into account window over launcher state during
+   *  the ws switch as we can get false positives
+   *  (like switching to an empty viewport while grabbing a fullscreen window)
+   */
+  if (strcmp (event, "start_viewport_switch") == 0)
+    launcher->EnableCheckWindowOverLauncher (false);
+  else if (strcmp (event, "end_viewport_switch") == 0)
   {
     // compute again the list of all window on the new viewport
     // to decide if we should or not hide the launcher
-    launcher->EnableHiddenStateCheck (true);
+    launcher->EnableCheckWindowOverLauncher (true);
     launcher->CheckWindowOverLauncher ();
   }
-
-    
   screen->handleCompizEvent (plugin, event, option);
   
 }
@@ -286,10 +290,8 @@
   return false;
 }
 
-bool
-UnityScreen::executeCommand (CompAction         *action,
-                             CompAction::State   state,
-                             CompOption::Vector &options)
+void
+UnityScreen::SendExecuteCommand ()
 {
   ubus_server_send_message (ubus_server_get_default (),
                             UBUS_PLACE_ENTRY_ACTIVATE_REQUEST,
@@ -297,6 +299,18 @@
                                            "/com/canonical/unity/applicationsplace/runner",
                                            0,
                                            ""));
+}
+
+bool
+UnityScreen::executeCommand (CompAction         *action,
+                             CompAction::State   state,
+                             CompOption::Vector &options)
+{
+  if (!screen->grabbed ())
+    SendExecuteCommand ();
+  else
+    _need_send_execute_command = true;
+    
   return false;
 }
 
@@ -750,6 +764,7 @@
     doShellRepaint (false)
 {
   _key_nav_mode_requested = false;
+  _need_send_execute_command = false;
   START_FUNCTION ();
   int (*old_handler) (Display *, XErrorEvent *);
   old_handler = XSetErrorHandler (NULL);
@@ -889,8 +904,6 @@
   self->launcherWindow->SetLayout(layout);
   self->launcherWindow->SetBackgroundColor(nux::Color(0x00000000));
   self->launcherWindow->ShowWindow(true);
-  self->launcherWindow->EnableInputWindow(true, "launcher", false, false);
-  self->launcherWindow->InputWindowEnableStruts(true);
   self->launcherWindow->SetEnterFocusInputArea (self->launcher);
 
   /* FIXME: this should not be manual, should be managed with a

=== modified file 'src/unityshell.h'
--- src/unityshell.h	2011-03-18 04:34:41 +0000
+++ src/unityshell.h	2011-03-21 19:14:32 +0000
@@ -150,6 +150,8 @@
 
     private:
 
+  void SendExecuteCommand ();
+
 	static gboolean
 	initPluginActions (gpointer data);
 
@@ -222,6 +224,7 @@
 	bool    allowWindowPaint;
 	bool    damaged;
 	bool    _key_nav_mode_requested;
+	bool    _need_send_execute_command;
 	CompOutput *_last_output;
 	CompWindowList _withRemovedNuxWindows;
 

=== modified file 'unityshell.xml.in'
--- unityshell.xml.in	2011-03-10 15:39:00 +0000
+++ unityshell.xml.in	2011-03-21 19:14:32 +0000
@@ -162,7 +162,7 @@
                     <_long>Animation played when the launcher is showing or hiding</_long>
                     <min>0</min>
                     <max>2</max>
-                    <default>0</default>
+                    <default>1</default>
                     <desc>
                         <value>0</value>
                         <_name>Fade on bfb and Slide</_name>