Merge lp:~unity-team/unity/3v1n0-quick-alt+tab-fixes into lp:unity

[Marco Trevisan (Treviño)]

Fix the behaviour of alt-tab and clicking on the launcher icon to just raise the most recently used window, not all for that app.

BamfLauncherIcon's activation related code has been updated to be more multimonitor aware (for free I've fixed also some bugs that caused the windows not to be put in spread mode in multi-monitor), and to support both the "Launcher only on Primary Monitor" and "Launcher on all monitors" options.

PluginAdapter's FocusWindowGroup method has been updated to optionally only unminimize / raise and activate only the top window. This code would have been more optimized using a reverse iterator to fetch the top_window, but not to change the whole logic and to allow to keep the previous behavior (that initially we wanted for "long alt+tab") without duplicating code, I've just hacked that.
Implemented also GetWindowMonitor to workaround the mismatch we had with the compiz' window->outputDevice() and the UScreen values that now we use in the whole unity.

Screencast of the fixed version: http://ubuntuone.com/7YaWciQnaZHfzr35asSz0N

== Problem ==
Launcher, Alt-Tab - clicking on launcher item or selecting a app in Alt-Tab raises all app windows, not just most recently focused.

== Fix ==
BamfLauncherIcon's activation related code has been updated to be more multimonitor aware (for free I've fixed also some bugs that caused the windows not to be put in spread mode in multi-monitor), and to support both the "Launcher only on Primary Monitor" and "Launcher on all monitors" options.

PluginAdapter's FocusWindowGroup method has been updated to optionally only unminimize / raise and activate only the top window. This code would have been more optimized using a reverse iterator to fetch the top_window, but not to change the whole logic and to allow to keep the previous behavior (that initially we wanted for "long alt+tab") without duplicating code, I've just hacked that.
Implemented also GetWindowMonitor to workaround the mismatch we had with the compiz' window->outputDevice() and the UScreen values that now we use in the whole unity.

Screencast of the fixed version: http://ubuntuone.com/7YaWciQnaZHfzr35asSz0N

== Test ==
There are autopilot test for both bugs.

Thanks to Brandon for taking care of merging the old lp:~3v1n0/unity/quick-alt+tab-fixes with trunk and for the AP tests that I used as my base.

UNBLOCK

[Marco Trevisan (Treviño) (3v1n0)]

30 - if ((mapped && wm->IsWindowMapped(xid)) || !mapped)
31 + if ((mapped && wm->IsWindowMapped(xid) && !bamf_window_get_transient(BAMF_WINDOW(view))) || !mapped)
32 {

About this, I think I included that change mostly for testing purposes, I'm not sure it's actually wanted so move it out.

I didn't work too much on my branch lately since I didn't know if that was still the wanted desig, but if now it is, I'll be happy to get this merged :)

[Brandon Schaefer (brandontschaefer)]

I ran all the autopilot test that I thought these changes would effect.

Launcher Autopilot tests:
Ran 43 tests in 296.560s
OK

Switcher Autopilot tests:
Ran 21 tests in 187.666s
OK

Dash Autopilot tests:
Ran 32 tests in 225.549s
OK

[Sam Spilsbury (smspillaz)]

Tests OK, no iconic window regressions (which is what I was a little concerned about)

review: Approve

[Tim Penhey (thumper)]

Clicking on the launcher to reveal only the top most one works.

However the quick alt-tab one does not work.

If I have two terminal windows and one gedit. Focus gedit and quick alt-tab, it raises both terminals.

review: Needs Fixing

[Marco Trevisan (Treviño) (3v1n0)]

Probably it is caused by the fact that now we use a very small delay for the Alt+Tab.
A workaround could be to use another time reference to consider an Alt+Tab quick, more than the only window visibility.

I mean, even if the window is shown for 100ms or less, the Alt+Tab is surely a quick one (as there's no time to look to the content of the window).

[Brandon Schaefer (brandontschaefer)]

I just ended up making a timer called quick_tab_timer_, which will go for 200ms if you hold on to alt for any longer it makes quick_tab = false. Seems like a nice and customizable way.

[Alex Launi (alexlauni)]

It shouldn't be too difficult to automate the manual tests. Please do not merge this with the manual tests.

review: Needs Fixing (quality)

[Brandon Schaefer (brandontschaefer)]

@Alex

Sorry about having the manual test in there. I was trying to get this branch in 5.10 and was rushing to get it done. Never a good sign when it comes to quality. There are now autopilot test for each bug!

[Brandon Schaefer (brandontschaefer)]

So I guess diff continutes to complain about there not being a new line...I even took the trunk version of Switcher.txt and replaced it and it still gives that problem...

[Marco Trevisan (Treviño) (3v1n0)]

I've just checked this code again, there's a problem with the minimized windows when using the launcher icon.
Don't worry about that Brandon, I'll take care of that ;)

[Brandon Schaefer (brandontschaefer)]

Yeah, I just saw that. At lease we know what design wants now :). Thank you!

[lp:~unity-team/unity/3v1n0-quick-alt+tab-fixes]

1817. By Marco Trevisan (Treviño) on 2012-04-15

PluginAdapter: avoid to raise and unminimize top_window if already done

[Brandon Schaefer (brandontschaefer)]

Awesome work! Confirmed everything I could with only 1 monitor, bot AP test pass as well as doing a lot of manual testing :)

[lp:~unity-team/unity/3v1n0-quick-alt+tab-fixes]

1818. By Tim Penhey on 2012-04-15

Tweaks to the test.

1819. By Tim Penhey on 2012-04-15

More AP test tweaks.

1820. By Tim Penhey on 2012-04-16

Assert that the visible window stack is what we expect.

1821. By Tim Penhey on 2012-04-16

Add window stack assertions to the switcher tests.

1822. By Tim Penhey on 2012-04-16

Test the alt-tab appears on the monitor that has window focus.

[Tim Penhey (thumper)]

The code looks fine, and I've tested the behaviour and tweaked the AP tests. Thomi will review the tests.

review: Approve

[Thomi Richards (thomir)]

+1

review: Approve (quality)

=== modified file 'manual-tests/Switcher.txt'
--- manual-tests/Switcher.txt	2012-03-23 15:14:42 +0000
+++ manual-tests/Switcher.txt	2012-04-16 01:06:19 +0000
@@ -37,4 +37,4 @@
   When you press Alt+Tab to switch window, the application title in the top left
   of the panel should change inline with changes in alt-tab focus.
   Also the menus shouldn't ever show. Even if the mouse has been left over
-  the panel when starting the Alt+Tab.
\ No newline at end of file
+  the panel when starting the Alt+Tab.

=== modified file 'plugins/unityshell/src/BamfLauncherIcon.cpp'
--- plugins/unityshell/src/BamfLauncherIcon.cpp	2012-04-10 03:57:39 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.cpp	2012-04-16 01:06:19 +0000
@@ -182,15 +182,15 @@
 void BamfLauncherIcon::ActivateLauncherIcon(ActionArg arg)
 {
   SimpleLauncherIcon::ActivateLauncherIcon(arg);
-  bool scaleWasActive = WindowManager::Default()->IsScaleActive();
-  GList    *l;
+  WindowManager* wm = WindowManager::Default();
+  bool scaleWasActive = wm->IsScaleActive();
 
   bool active = IsActive();
   bool user_visible = IsRunning();
 
   if (arg.target && OwnsWindow(arg.target))
   {
-    WindowManager::Default()->Activate(arg.target);
+    wm->Activate(arg.target);
     return;
   }
 
@@ -204,29 +204,48 @@
     user_visible = bamf_view_user_visible(bamf_view);
 
     bool any_visible = false;
-    GList *children = bamf_view_get_children(bamf_view);
+    bool any_mapped = false;
+    bool any_on_monitor = (arg.monitor < 0);
+    int active_monitor = arg.monitor;
+    GList* children = bamf_view_get_children(bamf_view);
 
-    for (l = children; l; l = l->next)
+    for (GList* l = children; l; l = l->next)
     {
       if (!BAMF_IS_WINDOW(l->data))
         continue;
 
-      Window xid = bamf_window_get_xid(static_cast<BamfWindow*>(l->data));
+      auto view = static_cast<BamfView*>(l->data);
+      auto win = static_cast<BamfWindow*>(l->data);
+      Window xid = bamf_window_get_xid(win);
 
-      if (!any_visible && WindowManager::Default()->IsWindowOnCurrentDesktop(xid))
+      if (!any_visible && wm->IsWindowOnCurrentDesktop(xid))
       {
         any_visible = true;
       }
 
-      if (active && !WindowManager::Default()->IsWindowMapped(xid))
-      {
-        active = false;
+      if (!any_mapped && wm->IsWindowMapped(xid))
+      {
+        any_mapped = true;
+      }
+
+      if (!any_on_monitor && bamf_window_get_monitor(win) == arg.monitor &&
+          wm->IsWindowMapped(xid) && wm->IsWindowVisible(xid))
+      {
+        any_on_monitor = true;
+      }
+
+      if (bamf_view_is_active(view))
+      {
+        active_monitor = bamf_window_get_monitor(win);
       }
     }
 
     g_list_free(children);
 
-    if (!any_visible)
+    if (!any_visible || !any_mapped)
+      active = false;
+
+    if (any_on_monitor && arg.monitor >= 0 && active_monitor != arg.monitor)
       active = false;
   }
 
@@ -245,7 +264,7 @@
 
     if (scaleWasActive)
     {
-      WindowManager::Default()->TerminateScale();
+      wm->TerminateScale();
     }
 
     SetQuirk(QUIRK_STARTING, true);
@@ -257,7 +276,7 @@
     {
       if (scaleWasActive) // #5 above
       {
-        WindowManager::Default()->TerminateScale();
+        wm->TerminateScale();
         Focus(arg);
       }
       else // #2 above
@@ -272,7 +291,7 @@
     {
       if (scaleWasActive) // #4 above
       {
-        WindowManager::Default()->TerminateScale();
+        wm->TerminateScale();
         Focus(arg);
         if (arg.source != ActionArg::SWITCHER)
           Spread(true, 0, false);
@@ -290,9 +309,9 @@
 
 std::vector<Window> BamfLauncherIcon::GetWindows(WindowFilterMask filter, int monitor)
 {
+  WindowManager* wm = WindowManager::Default();
   std::vector<Window> results;
   GList* children, *l;
-  WindowManager *wm = WindowManager::Default();
 
   monitor = (filter & WindowFilter::ON_ALL_MONITORS) ? -1 : monitor;
   bool mapped = (filter & WindowFilter::MAPPED);
@@ -546,17 +565,16 @@
 
 void BamfLauncherIcon::Focus(ActionArg arg)
 {
-  GList* children, *l;
   bool any_urgent = false;
   bool any_visible = false;
   bool any_user_visible = false;
-
-  children = bamf_view_get_children(BAMF_VIEW(_bamf_app.RawPtr()));
+  WindowManager* wm = WindowManager::Default();
 
   std::vector<Window> windows;
+  GList* children = bamf_view_get_children(BAMF_VIEW(_bamf_app.RawPtr()));
 
   /* get the list of windows */
-  for (l = children; l; l = l->next)
+  for (GList* l = children; l; l = l->next)
   {
     if (!BAMF_IS_WINDOW(l->data))
       continue;
@@ -590,32 +608,29 @@
       windows.push_back(xid);
     }
 
-    if (WindowManager::Default()->IsWindowOnCurrentDesktop(xid) &&
-        WindowManager::Default()->IsWindowVisible(xid))
+    if (wm->IsWindowOnCurrentDesktop(xid) && wm->IsWindowVisible(xid))
     {
       any_visible = true;
     }
   }
+
   g_list_free(children);
 
+  auto visibility = WindowManager::FocusVisibility::OnlyVisible;
+
   if (arg.source != ActionArg::SWITCHER)
   {
     if (any_visible)
     {
-      WindowManager::Default()->FocusWindowGroup(windows,
-       WindowManager::FocusVisibility::ForceUnminimizeInvisible, arg.monitor);
+      visibility = WindowManager::FocusVisibility::ForceUnminimizeInvisible;
     }
     else
     {
-      WindowManager::Default()->FocusWindowGroup(windows,
-       WindowManager::FocusVisibility::ForceUnminimizeOnCurrentDesktop, arg.monitor);
+      visibility = WindowManager::FocusVisibility::ForceUnminimizeOnCurrentDesktop;
     }
   }
-  else
-  {
-    WindowManager::Default()->FocusWindowGroup(windows,
-      WindowManager::FocusVisibility::OnlyVisible, arg.monitor);
-  }
+
+  wm->FocusWindowGroup(windows, visibility, arg.monitor);
 }
 
 bool BamfLauncherIcon::Spread(bool current_desktop, int state, bool force)

=== modified file 'plugins/unityshell/src/Launcher.cpp'
--- plugins/unityshell/src/Launcher.cpp	2012-04-10 01:41:16 +0000
+++ plugins/unityshell/src/Launcher.cpp	2012-04-16 01:06:19 +0000
@@ -2553,7 +2553,9 @@
 
     if (GetActionState() == ACTION_NONE)
     {
-      _icon_mouse_down->mouse_click.emit(nux::GetEventButton(button_flags), monitor);
+      /* This will inform the icon if the action is valid for all the monitors */
+      int action_monitor = options()->show_for_all ? -1 : monitor;
+      _icon_mouse_down->mouse_click.emit(nux::GetEventButton(button_flags), action_monitor);
     }
   }
 

=== modified file 'plugins/unityshell/src/PluginAdapter.cpp'
--- plugins/unityshell/src/PluginAdapter.cpp	2012-04-02 10:45:47 +0000
+++ plugins/unityshell/src/PluginAdapter.cpp	2012-04-16 01:06:19 +0000
@@ -20,6 +20,7 @@
 #include <glib.h>
 #include <sstream>
 #include "PluginAdapter.h"
+#include "UScreen.h"
 
 #include <NuxCore/Logger.h>
 
@@ -392,6 +393,12 @@
 }
 
 // WindowManager implementation
+guint32
+PluginAdapter::GetActiveWindow()
+{
+  return m_Screen->activeWindow();
+}
+
 bool
 PluginAdapter::IsWindowMaximized(guint xid)
 {
@@ -618,11 +625,12 @@
 }
 
 void 
-PluginAdapter::FocusWindowGroup(std::vector<Window> window_ids, FocusVisibility focus_visibility, int monitor)
+PluginAdapter::FocusWindowGroup(std::vector<Window> window_ids, FocusVisibility focus_visibility, int monitor, bool only_top_win)
 {
   CompPoint target_vp = m_Screen->vp();
-  CompWindow* top_window = NULL;
-  CompWindow* top_window_on_monitor = NULL;
+  CompWindow* top_window = nullptr;
+  CompWindow* top_monitor_win = nullptr;
+
   bool any_on_current = false;
   bool any_mapped = false;
   bool any_mapped_on_current = false;
@@ -661,11 +669,12 @@
 
   if (!any_on_current)
   {
-    for (auto it = windows.rbegin(); it != windows.rend(); it++)
+    for (auto it = windows.rbegin(); it != windows.rend(); ++it)
     {
-      if ((any_mapped && !(*it)->minimized()) || !any_mapped)
+      CompWindow* win = *it;
+      if ((any_mapped && !win->minimized()) || !any_mapped)
       {
-        target_vp = (*it)->defaultViewport();
+        target_vp = win->defaultViewport();
         break;
       }
     }
@@ -675,46 +684,64 @@
   {
     if (win->defaultViewport() == target_vp)
     {
-       /* Any window which is actually unmapped is
-        * not going to be accessible by either switcher
-        * or scale, so unconditionally unminimize those
-        * windows when the launcher icon is activated */
-       if ((focus_visibility == WindowManager::FocusVisibility::ForceUnminimizeOnCurrentDesktop &&
-            target_vp == m_Screen->vp()) ||
-            (focus_visibility == WindowManager::FocusVisibility::ForceUnminimizeInvisible &&
-             win->mapNum () == 0))
-       {
-         bool is_mapped = win->mapNum () != 0;
-         top_window = win;
-         if (monitor >= 0 && win->outputDevice() == monitor)
-          top_window_on_monitor = win;
-         win->unminimize ();
-
-         forced_unminimize = true;
-
-         /* Initially minimized windows dont get raised */
-         if (!is_mapped)
-           win->raise ();
-       }
-       else if ((any_mapped_on_current && !win->minimized()) || !any_mapped_on_current)
-       {
-         if (!forced_unminimize || target_vp == m_Screen->vp())
-         {
-           win->raise();
-           top_window = win;
-           if (monitor >= 0 && win->outputDevice() == monitor)
-            top_window_on_monitor = win;
-         }
-       }
-    }
-  }
-
-  if (monitor > 0 && top_window_on_monitor)
-  {
-    top_window_on_monitor->activate();
-  }
-  else if (top_window)
-  {
+      int win_monitor = GetWindowMonitor(win->id());
+
+      /* Any window which is actually unmapped is
+      * not going to be accessible by either switcher
+      * or scale, so unconditionally unminimize those
+      * windows when the launcher icon is activated */
+      if ((focus_visibility == WindowManager::FocusVisibility::ForceUnminimizeOnCurrentDesktop &&
+          target_vp == m_Screen->vp()) ||
+          (focus_visibility == WindowManager::FocusVisibility::ForceUnminimizeInvisible &&
+           win->mapNum() == 0))
+      {
+        top_window = win;
+        forced_unminimize = true;
+
+        if (monitor >= 0 && win_monitor == monitor)
+          top_monitor_win = win;
+
+        if (!only_top_win)
+        {
+          bool is_mapped = (win->mapNum() != 0);
+          win->unminimize();
+
+           /* Initially minimized windows dont get raised */
+          if (!is_mapped)
+            win->raise();
+        }
+      }
+      else if ((any_mapped_on_current && !win->minimized()) || !any_mapped_on_current)
+      {
+        if (!forced_unminimize || target_vp == m_Screen->vp())
+        {
+          top_window = win;
+
+          if (monitor >= 0 && win_monitor == monitor)
+            top_monitor_win = win;
+
+          if (!only_top_win)
+            win->raise();
+        }
+      }
+    }
+  }
+
+  if (monitor >= 0 && top_monitor_win)
+    top_window = top_monitor_win;
+
+  if (top_window)
+  {
+    if (only_top_win)
+    {
+      if (forced_unminimize)
+        {
+          top_window->unminimize();
+        }
+
+      top_window->raise();
+    }
+
     top_window->activate();
   }
 }
@@ -768,12 +795,29 @@
   _in_show_desktop = false;
 }
 
+int
+PluginAdapter::GetWindowMonitor(guint32 xid) const
+{
+  // FIXME, we should use window->outputDevice() but this is not UScreen friendly
+  nux::Geometry const& geo = GetWindowGeometry(xid);
+
+  if (!geo.IsNull())
+  {
+    int x = geo.x + geo.width/2;
+    int y = geo.y + geo.height/2;
+
+    return UScreen::GetDefault()->GetMonitorAtPosition(x, y);
+  }
+
+  return -1;
+}
+
 nux::Geometry
 PluginAdapter::GetWindowGeometry(guint32 xid) const
 {
   Window win = xid;
   CompWindow* window;
-  nux::Geometry geo(0, 0, 1, 1);
+  nux::Geometry geo;
 
   window = m_Screen->findWindow(win);
   if (window)

=== modified file 'plugins/unityshell/src/PluginAdapter.h'
--- plugins/unityshell/src/PluginAdapter.h	2012-04-02 10:45:47 +0000
+++ plugins/unityshell/src/PluginAdapter.h	2012-04-16 01:06:19 +0000
@@ -109,6 +109,8 @@
   void NotifyCompizEvent(const char* plugin, const char* event, CompOption::Vector& option);
   void NotifyNewDecorationState(guint32 xid);
 
+  guint32 GetActiveWindow();
+
   void Decorate(guint32 xid);
   void Undecorate(guint32 xid);
 
@@ -132,7 +134,7 @@
 
   void SetWindowIconGeometry(Window window, nux::Geometry const& geo);
 
-  void FocusWindowGroup(std::vector<Window> windows, FocusVisibility, int monitor = -1);
+  void FocusWindowGroup(std::vector<Window> windows, FocusVisibility, int monitor = -1, bool only_top_win = true);
   bool ScaleWindowGroup(std::vector<Window> windows, int state, bool force);
 
   bool IsScreenGrabbed();
@@ -142,6 +144,7 @@
 
   bool MaximizeIfBigEnough(CompWindow* window);
 
+  int GetWindowMonitor(guint32 xid) const;
   nux::Geometry GetWindowGeometry(guint32 xid) const;
   nux::Geometry GetWindowSavedGeometry(guint32 xid) const;
   nux::Geometry GetScreenGeometry() const;

=== modified file 'plugins/unityshell/src/SwitcherController.cpp'
--- plugins/unityshell/src/SwitcherController.cpp	2012-04-04 00:00:05 +0000
+++ plugins/unityshell/src/SwitcherController.cpp	2012-04-16 01:06:19 +0000
@@ -507,6 +507,7 @@
   .add("initial-detail-timeout-length", initial_detail_timeout_length())
   .add("detail-timeout-length", detail_timeout_length())
   .add("visible", visible_)
+  .add("monitor", monitor_)
   .add("detail-mode", detail_mode_);
 }
 

=== modified file 'plugins/unityshell/src/UScreen.cpp'
--- plugins/unityshell/src/UScreen.cpp	2012-03-29 20:07:45 +0000
+++ plugins/unityshell/src/UScreen.cpp	2012-04-16 01:06:19 +0000
@@ -59,19 +59,17 @@
 int
 UScreen::GetMonitorWithMouse()
 {
-  GdkScreen* screen;
   GdkDevice* device;
   GdkDisplay *display;
   int x;
   int y;
 
-  screen = gdk_screen_get_default();
   display = gdk_display_get_default();
   device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(display));
 
   gdk_device_get_position(device, NULL, &x, &y);
 
-  return gdk_screen_get_monitor_at_point(screen, x, y);
+  return GetMonitorAtPosition(x, y);
 }
 
 int
@@ -80,6 +78,14 @@
   return primary_;
 }
 
+int
+UScreen::GetMonitorAtPosition(int x, int y)
+{
+  GdkScreen* screen = gdk_screen_get_default();
+
+  return gdk_screen_get_monitor_at_point(screen, x, y);
+}
+
 nux::Geometry&
 UScreen::GetMonitorGeometry(int monitor)
 {

=== modified file 'plugins/unityshell/src/UScreen.h'
--- plugins/unityshell/src/UScreen.h	2012-03-29 20:07:45 +0000
+++ plugins/unityshell/src/UScreen.h	2012-04-16 01:06:19 +0000
@@ -36,6 +36,7 @@
 
   int             GetPrimaryMonitor();
   int             GetMonitorWithMouse();
+  int             GetMonitorAtPosition(int x, int y);
   nux::Geometry&  GetMonitorGeometry(int monitor);
 
   std::vector<nux::Geometry>& GetMonitors();

=== modified file 'plugins/unityshell/src/WindowManager.cpp'
--- plugins/unityshell/src/WindowManager.cpp	2012-04-02 10:45:47 +0000
+++ plugins/unityshell/src/WindowManager.cpp	2012-04-16 01:06:19 +0000
@@ -23,6 +23,11 @@
 
 class WindowManagerDummy : public WindowManager
 {
+  guint32 GetActiveWindow()
+  {
+    return 0;
+  }
+
   unsigned long long GetWindowActiveNumber (guint32 xid)
   {
     return 0;
@@ -113,7 +118,7 @@
     g_debug("%s", G_STRFUNC);
   }
 
-  void FocusWindowGroup(std::vector<Window> windows, FocusVisibility, int monitor)
+  void FocusWindowGroup(std::vector<Window> windows, FocusVisibility, int monitor, bool only_top_win)
   {
     g_debug("%s", G_STRFUNC);
   }
@@ -124,6 +129,11 @@
     return false;
   }
 
+  int GetWindowMonitor(guint32 xid) const
+  {
+    return -1;
+  }
+
   nux::Geometry GetWindowGeometry(guint xid) const
   {
     int width = (guint32)xid >> 16;

=== modified file 'plugins/unityshell/src/WindowManager.h'
--- plugins/unityshell/src/WindowManager.h	2012-04-02 10:45:47 +0000
+++ plugins/unityshell/src/WindowManager.h	2012-04-16 01:06:19 +0000
@@ -53,7 +53,9 @@
   };
 
   static WindowManager* Default();
-  static void            SetDefault(WindowManager* manager);
+  static void           SetDefault(WindowManager* manager);
+
+  virtual guint32 GetActiveWindow() = 0;
 
   virtual bool IsWindowMaximized(guint32 xid) = 0;
   virtual bool IsWindowDecorated(guint32 xid) = 0;
@@ -81,7 +83,7 @@
   virtual void InitiateExpo() = 0;
   virtual bool IsExpoActive() = 0;
 
-  virtual void FocusWindowGroup(std::vector<Window> windows, FocusVisibility, int monitor = -1) = 0;
+  virtual void FocusWindowGroup(std::vector<Window> windows, FocusVisibility, int monitor = -1, bool only_top_win = true) = 0;
   virtual bool ScaleWindowGroup(std::vector<Window> windows, int state, bool force) = 0;
 
   virtual void Decorate(guint32 xid) {};
@@ -93,6 +95,7 @@
   virtual void MoveResizeWindow(guint32 xid, nux::Geometry geometry) = 0;
   void StartMove(guint32 xid, int, int);
 
+  virtual int GetWindowMonitor(guint32 xid) const = 0;
   virtual nux::Geometry GetWindowGeometry(guint32 xid) const = 0;
   virtual nux::Geometry GetWindowSavedGeometry(guint32 xid) const = 0;
   virtual nux::Geometry GetScreenGeometry() const = 0;

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-04-11 16:29:31 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-04-16 01:06:19 +0000
@@ -1711,11 +1711,14 @@
 
   // maybe check launcher position/hide state?
 
-  int device = screen->outputDeviceForPoint (pointerX, pointerY);
-  switcher_controller_->SetWorkspace(nux::Geometry(screen->outputDevs()[device].x1() + 100,
-                                                 screen->outputDevs()[device].y1() + 100,
-                                                 screen->outputDevs()[device].width() - 200,
-                                                 screen->outputDevs()[device].height() - 200), device);
+  WindowManager *wm = WindowManager::Default();
+  int monitor = wm->GetWindowMonitor(wm->GetActiveWindow());
+  nux::Geometry monitor_geo = UScreen::GetDefault()->GetMonitorGeometry(monitor);
+  monitor_geo.x += 100;
+  monitor_geo.y += 100;
+  monitor_geo.width -= 200;
+  monitor_geo.height -= 200;
+  switcher_controller_->SetWorkspace(monitor_geo, monitor);
 
   if (!optionGetAltTabBiasViewport())
   {

=== modified file 'tests/autopilot/autopilot/emulators/bamf.py'
--- tests/autopilot/autopilot/emulators/bamf.py	2012-04-05 03:41:38 +0000
+++ tests/autopilot/autopilot/emulators/bamf.py	2012-04-16 01:06:19 +0000
@@ -81,12 +81,21 @@
         If user_visible_only is True (the default), only applications
         visible to the user in the switcher will be returned.
 
+        The result is sorted to be in stacking order.
+
         """
 
+        # Get the stacking order from the root window.
+        root_win = _X_DISPLAY.screen().root
+        prop = root_win.get_full_property(
+            _X_DISPLAY.get_atom('_NET_CLIENT_LIST_STACKING'), X.AnyPropertyType)
+        stack = prop.value.tolist()
+
         windows = [BamfWindow(w) for w in self.matcher_interface.WindowPaths()]
         if user_visible_only:
-            return filter(_filter_user_visible, windows)
-        return windows
+            windows = filter(_filter_user_visible, windows)
+        # Now sort on stacking order.
+        return sorted(windows, key=lambda w: stack.index(w.x_id), reverse=True)
 
     def wait_until_application_is_running(self, desktop_file, timeout):
         """Wait until a given application is running.

=== modified file 'tests/autopilot/autopilot/emulators/unity/switcher.py'
--- tests/autopilot/autopilot/emulators/unity/switcher.py	2012-04-02 20:18:58 +0000
+++ tests/autopilot/autopilot/emulators/unity/switcher.py	2012-04-16 01:06:19 +0000
@@ -157,6 +157,9 @@
     def get_is_visible(self):
         return bool(self.__get_controller()['visible'])
 
+    def get_monitor(self):
+        return int(self.__get_controller()['monitor'])
+
     def get_is_in_details_mode(self):
         """Return True if the SwitcherView is in details mode."""
         return bool(self.__get_model()['detail-selection'])

=== modified file 'tests/autopilot/autopilot/tests/__init__.py'
--- tests/autopilot/autopilot/tests/__init__.py	2012-04-11 06:32:50 +0000
+++ tests/autopilot/autopilot/tests/__init__.py	2012-04-16 01:06:19 +0000
@@ -335,3 +335,15 @@
         controllers = PanelController.get_all_instances()
         self.assertThat(len(controllers), Equals(1))
         return controllers[0]
+
+    def assertVisibleWindowStack(self, stack_start):
+        """Check that the visible window stack starts with the windows passed in.
+
+        The start_stack is an iterable of BamfWindow objects.
+        Minimised windows are skipped.
+
+        """
+        stack = [win for win in self.bamf.get_open_windows() if not win.is_hidden]
+        for pos, win in enumerate(stack_start):
+            self.assertThat(stack[pos].x_id, Equals(win.x_id),
+                            "%r at %d does not equal %r" % (stack[pos], pos, win))

=== modified file 'tests/autopilot/autopilot/tests/test_launcher.py'
--- tests/autopilot/autopilot/tests/test_launcher.py	2012-04-06 07:31:45 +0000
+++ tests/autopilot/autopilot/tests/test_launcher.py	2012-04-16 01:06:19 +0000
@@ -403,6 +403,71 @@
         self.assertThat(self.launcher.key_nav_is_active, Equals(False))
 
 
+class LauncherIconsBehaviorTests(LauncherTestCase):
+    """Test the launcher icons interactions"""
+
+    def test_launcher_activate_last_focused_window(self):
+        """This tests shows that when you activate a launcher icon only the last
+        focused instance of that application is rasied.
+
+        This is tested by opening 2 Mahjongg and a Calculator.
+        Then we activate the Calculator launcher icon.
+        Then we actiavte the Mahjongg launcher icon.
+        Then we minimize the focused applications.
+        This should give focus to the next window on the stack.
+        Then we activate the Mahjongg launcher icon
+        This should bring to focus the non-minimized window.
+        If only 1 instance is raised then the Calculator gets the focus.
+        If ALL the instances are raised then the second Mahjongg gets the focus.
+
+        """
+        mahj = self.start_app("Mahjongg")
+        [mah_win1] = mahj.get_windows()
+        self.assertTrue(mah_win1.is_focused)
+
+        calc = self.start_app("Calculator")
+        [calc_win] = calc.get_windows()
+        self.assertTrue(calc_win.is_focused)
+
+        self.start_app("Mahjongg")
+        # Sleeping due to the start_app only waiting for the bamf model to be
+        # updated with the application.  Since the app has already started,
+        # and we are just waiting on a second window, however a defined sleep
+        # here is likely to be problematic.
+        # TODO: fix bamf emulator to enable waiting for new windows.
+        sleep(1)
+        [mah_win2] = [w for w in mahj.get_windows() if w.x_id != mah_win1.x_id]
+        self.assertTrue(mah_win2.is_focused)
+
+        self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+
+        mahj_icon = self.launcher.model.get_icon_by_desktop_id(mahj.desktop_file)
+        calc_icon = self.launcher.model.get_icon_by_desktop_id(calc.desktop_file)
+
+        self.launcher_instance.click_launcher_icon(calc_icon)
+        sleep(1)
+        self.assertTrue(calc_win.is_focused)
+        self.assertVisibleWindowStack([calc_win, mah_win2, mah_win1])
+
+        self.launcher_instance.click_launcher_icon(mahj_icon)
+        sleep(1)
+        self.assertTrue(mah_win2.is_focused)
+        self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+
+        self.keybinding("window/minimize")
+        sleep(1)
+
+        self.assertTrue(mah_win2.is_hidden)
+        self.assertTrue(calc_win.is_focused)
+        self.assertVisibleWindowStack([calc_win, mah_win1])
+
+        self.launcher_instance.click_launcher_icon(mahj_icon)
+        sleep(1)
+        self.assertTrue(mah_win1.is_focused)
+        self.assertTrue(mah_win2.is_hidden)
+        self.assertVisibleWindowStack([mah_win1, calc_win])
+
+
 class LauncherRevealTests(LauncherTestCase):
     """Test the launcher reveal bahavior when in autohide mode."""
 

=== modified file 'tests/autopilot/autopilot/tests/test_switcher.py'
--- tests/autopilot/autopilot/tests/test_switcher.py	2012-04-03 13:48:39 +0000
+++ tests/autopilot/autopilot/tests/test_switcher.py	2012-04-16 01:06:19 +0000
@@ -21,9 +21,9 @@
     def setUp(self):
         super(SwitcherTests, self).setUp()
 
-        self.start_app('Character Map')
-        self.start_app('Calculator')
-        self.start_app('Mahjongg')
+        self.char_map = self.start_app('Character Map')
+        self.calc = self.start_app('Calculator')
+        self.mahjongg = self.start_app('Mahjongg')
 
     def tearDown(self):
         super(SwitcherTests, self).tearDown()
@@ -197,6 +197,69 @@
 
         self.assertThat(self.switcher.get_is_visible(), Equals(False))
 
+    def test_switcher_appears_on_monitor_with_focused_window(self):
+        num_monitors = self.screen_geo.get_num_monitors()
+        if num_monitors == 1:
+            self.skip("No point testing this on one monitor")
+
+        [calc_win] = self.calc.get_windows()
+        for monitor in range(num_monitors):
+            self.screen_geo.drag_window_to_monitor(calc_win, monitor)
+            self.switcher.initiate()
+            sleep(1)
+            self.assertThat(self.switcher.get_monitor(), Equals(monitor))
+            self.switcher.terminate()
+
+
+class SwitcherWindowsManagementTests(AutopilotTestCase):
+    """Test the switcher window management."""
+
+    def test_switcher_raises_only_last_focused_window(self):
+        """Tests that when we do an alt+tab only the previously focused window
+        is raised.
+        This is tests by opening 2 Calculators and a Mahjongg.
+        Then we do a quick alt+tab twice.
+        Then we close the currently focused window.
+        """
+        self.close_all_app("Mahjongg")
+        self.close_all_app("Calculator")
+
+        mahj = self.start_app("Mahjongg")
+        [mah_win1] = mahj.get_windows()
+        self.assertTrue(mah_win1.is_focused)
+
+        calc = self.start_app("Calculator")
+        [calc_win] = calc.get_windows()
+        self.assertTrue(calc_win.is_focused)
+
+        self.start_app("Mahjongg")
+        # Sleeping due to the start_app only waiting for the bamf model to be
+        # updated with the application.  Since the app has already started,
+        # and we are just waiting on a second window, however a defined sleep
+        # here is likely to be problematic.
+        # TODO: fix bamf emulator to enable waiting for new windows.
+        sleep(1)
+        [mah_win2] = [w for w in mahj.get_windows() if w.x_id != mah_win1.x_id]
+        self.assertTrue(mah_win2.is_focused)
+
+        self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+
+        self.keybinding("switcher/reveal_normal")
+        sleep(1)
+        self.assertTrue(calc_win.is_focused)
+        self.assertVisibleWindowStack([calc_win, mah_win2, mah_win1])
+
+        self.keybinding("switcher/reveal_normal")
+        sleep(1)
+        self.assertTrue(mah_win2.is_focused)
+        self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+
+        self.keybinding("window/close")
+        sleep(1)
+
+        self.assertTrue(calc_win.is_focused)
+        self.assertVisibleWindowStack([calc_win, mah_win1])
+
 
 class SwitcherDetailsTests(AutopilotTestCase):
     """Test the details mode for the switcher."""
@@ -364,4 +427,3 @@
         # current workspace and ask that one if it is hidden.
         self.assertFalse(wins[0].is_hidden)
         self.assertFalse(wins[1].is_hidden)
-