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

[Brandon Schaefer]

Fixes quick alt+tab and also fixes clicking on a launcher icon to raise the last focused application.

Grabbed 3v1n0's quick alt+tab fix branch:
https://code.launchpad.net/~3v1n0/unity/quick-alt+tab-fixes/+merge/85583 and merged it with trunk and fixed the conflicts. This problem is very similar to this bug: https://bugs.launchpad.net/unity/+bug/959339 which this branch also now fixes that bug!

== Problem ==
Quick alt+tab and clicking on a launcher icon raises all of the applications of that type.

== Fix ==
The fix was to add 'OnlyVisibleOnTop' to the enum WindowManager::FocusVisibility so when you want to only focus the top window use that.

To use Quick alt+tab you have to press alt+tab before a timer goes off. Right now it is set to 200ms, but is very easy to change.

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

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

[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).

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

1785. By Brandon Schaefer on 2012-04-06

* Merged trunk

[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.

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

1786. By Brandon Schaefer on 2012-04-06

* Added a timer for quick tab

1787. By Brandon Schaefer on 2012-04-06

* fixed manual test I messed up

1788. By Brandon Schaefer on 2012-04-07

* Added 2 autopilot test showing quick tab is true when pressed fast enough

1789. By Brandon Schaefer on 2012-04-10

* merged trunk

1790. By Brandon Schaefer on 2012-04-11

* merged trunk

[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)

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

1791. By Brandon Schaefer on 2012-04-12

* Added more autopilot test for quick alt+tab

1792. By Brandon Schaefer on 2012-04-13

* Add autopilot test for both bugs!

1793. By Brandon Schaefer on 2012-04-13

* removed random dash '-'

1794. By Brandon Schaefer on 2012-04-13

* merged trunk

[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!

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

1795. By Brandon Schaefer on 2012-04-13

* Fixed the No new line error diff was reporting

1796. By Brandon Schaefer on 2012-04-13

* remove extra line

[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]

1797. By Marco Trevisan (Treviño) on 2012-04-14

PluginAdapter::FocusWindowGroup: add a parameter to define if focusing the on-top window only

This allow to be more monitor/VP safe

1798. By Marco Trevisan (Treviño) on 2012-04-14

unityshell: switcher, use UScreen to get the monitor value.

Not using this can cause inconsistences, due to the fact that compiz
numbers the devices in a different way.

1799. By Marco Trevisan (Treviño) on 2012-04-14

UScreen: allow to get the monitor for a given point

1800. By Marco Trevisan (Treviño) on 2012-04-14

WindowManager: add GetWindowMonitor method, and use UScreen to fetch it

This now used in PluginAdapter not to have inconsistences.

1801. By Marco Trevisan (Treviño) on 2012-04-14

SwitcherController: include the switcher monitor when activating a group

1802. By Marco Trevisan (Treviño) on 2012-04-14

Launcher: if the current launcher is used for all the monitors, don't filter windows per monitor

1803. By Marco Trevisan (Treviño) on 2012-04-14

BamfLauncherIcon: focus a window if the application is not active on the current monitor

1804. By Marco Trevisan (Treviño) on 2012-04-14

BamfLauncherIcon: don't consider an unmapped window as one in monitor

1805. By Marco Trevisan (Treviño) on 2012-04-14

BamfLauncherIcon: Also invisible windows shouldn't be counted as available in monitor

Now the spread works as expected, clicking on each monitor's panel! ;)

1806. By Marco Trevisan (Treviño) on 2012-04-14

autopilot: fixed the AP test

1807. By Marco Trevisan (Treviño) on 2012-04-14

SwitcherController: Removing the code for the Quick Alt+Tab, it should behave always at the same way

19:11:04 <JohnLea> so to summarize the above, when a app icon is selected
in Alt-Tab, the most recently focused window (on any monitor, but only in
the current workspace) of that application which is not minimised
should be focused

1808. By Marco Trevisan (Treviño) on 2012-04-14

Merging with branch changes

1809. By Marco Trevisan (Treviño) on 2012-04-14

PluginAdapter: removing debugging bits

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

WindowManager: add method to get the active window.

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

unityshell: show the Alt+Tab window in the monitor where is the active window

As per design.

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

autopilot, test_switcher: updated against new updates

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

autopilot, test_launcher: updated click test to check minimized windows too

Removed debug data

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

WindowManager, BamfLauncherIcon: some code cleanup

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

UScreen: use GetMonitorAtPosition in GetMonitorWithMouse

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

Launcher: be more clear in comment (yeah?)

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

PluginAdapter: avoid to raise and unminimize top_window if already done

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.

Unmerged revisions

=== modified file 'manual-tests/Switcher.txt'
--- manual-tests/Switcher.txt	2012-03-23 15:14:42 +0000
+++ manual-tests/Switcher.txt	2012-04-15 12:16:20 +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-15 12:16:20 +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-15 12:16:20 +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-15 12:16:20 +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,56 @@
   {
     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;
-         }
-       }
+      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_window_on_monitor)
-  {
-    top_window_on_monitor->activate();
-  }
-  else if (top_window)
-  {
+  if (monitor >= 0 && top_monitor_win)
+    top_window = top_monitor_win;
+
+  if (top_window)
+  {
+    top_window->unminimize();
+    top_window->raise();
     top_window->activate();
   }
 }
@@ -768,12 +787,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-15 12:16:20 +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/UScreen.cpp'
--- plugins/unityshell/src/UScreen.cpp	2012-03-29 20:07:45 +0000
+++ plugins/unityshell/src/UScreen.cpp	2012-04-15 12:16:20 +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-15 12:16:20 +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-15 12:16:20 +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-15 12:16:20 +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-15 12:16:20 +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/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-15 12:16:20 +0000
@@ -403,6 +403,69 @@
         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.
+
+        """
+        self.close_all_app("Mahjongg")
+        self.close_all_app("Calculator")
+
+        mahj = self.start_app("Mahjongg")
+        wins = mahj.get_windows()
+        self.assertThat(len(wins), Equals(1))
+        mah_win1 = wins[0]
+        self.assertTrue(mah_win1.is_focused)
+
+        calc = self.start_app("Calculator")
+        wins = calc.get_windows()
+        self.assertThat(len(wins), Equals(1))
+        calc_win = wins[0]
+        self.assertTrue(calc_win.is_focused)
+
+        self.start_app("Mahjongg")
+        sleep(1)
+        wins = filter(lambda w: w.x_id != mah_win1.x_id, mahj.get_windows())
+        self.assertThat(len(wins), Equals(1))
+        mah_win2 = wins[0]
+        self.assertTrue(mah_win2.is_focused)
+
+        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.launcher_instance.click_launcher_icon(mahj_icon)
+        sleep(1)
+        self.assertTrue(mah_win2.is_focused)
+
+        self.keybinding("window/minimize")
+        sleep(1)
+
+        self.assertTrue(mah_win2.is_hidden)
+        self.assertTrue(calc_win.is_focused)
+
+        self.launcher_instance.click_launcher_icon(mahj_icon)
+        sleep(1)
+        self.assertTrue(mah_win1.is_focused)
+        self.assertTrue(mah_win2.is_hidden)
+
+
 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-15 12:16:20 +0000
@@ -198,6 +198,51 @@
         self.assertThat(self.switcher.get_is_visible(), Equals(False))
 
 
+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")
+
+        calc = self.start_app("Calculator")
+        wins = calc.get_windows()
+        self.assertThat(len(wins), Equals(1))
+        calc_win1 = wins[0]
+        self.assertTrue(calc_win1.is_focused)
+
+        mahj = self.start_app("Mahjongg")
+        wins = mahj.get_windows()
+        self.assertThat(len(wins), Equals(1))
+        mahj_win = wins[0]
+        self.assertTrue(mahj_win.is_focused)
+
+        self.start_app("Calculator")
+        sleep(1)
+        wins = filter(lambda w: w.x_id != calc_win1.x_id, calc.get_windows())
+        self.assertThat(len(wins), Equals(1))
+        calc_win2 = wins[0]
+        self.assertTrue(calc_win2.is_focused)
+
+        self.keybinding("switcher/reveal_normal")
+        sleep(1)
+        self.assertTrue(mahj_win.is_focused)
+
+        self.keybinding("switcher/reveal_normal")
+        sleep(1)
+        self.assertTrue(calc_win2.is_focused)
+
+        self.keybinding("window/close")
+        sleep(1)
+
+        self.assertTrue(mahj_win.is_focused)
+
 class SwitcherDetailsTests(AutopilotTestCase):
     """Test the details mode for the switcher."""
 
@@ -364,4 +409,3 @@
         # current workspace and ask that one if it is hidden.
         self.assertFalse(wins[0].is_hidden)
         self.assertFalse(wins[1].is_hidden)
-