Merge lp:~3v1n0/unity/ups-menu-close-on-keybindings into lp:unity

[Marco Trevisan (Treviño)]

PanelService: close a menu and re-send the keyevent when handling a combination

Or when we try to open HUD/Dash. Also, close the active menu if a new application is opened
and focused.

Make the PanelService to ignore all the <Meta>+<key> keybindings and to reinject them to the X server root window so that the WindowManager can process them. Also monitor HUD and Dash keybindings and blacklist them.

We also now listen to the indicators signals about opening invalid entries as an hint to close our menus if the focused window has just been changed.

Added new AP tests.

[Brandon Schaefer (brandontschaefer)]

Hmm my menus don't seem to want to close, but it is getting the super event. If I open the menu press super, the menu stays open then I click outside to close then the dash appears....

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3562
http://jenkins.qa.ubuntu.com/job/unity-ci/414/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/303/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/301/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/302/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-ci/414/rebuild

review: Needs Fixing (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

It working now! Forgot to start my compiled version of u-p-s :).

Everything looks good...but im also tired haha... would like a second set of eyes, or ill re-review it tomorrow.

[Christopher Townsend (townsend)]

This looks all good. Very nice!

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3563
http://jenkins.qa.ubuntu.com/job/unity-ci/418/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/307
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/305
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/306

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-ci/418/rebuild

review: Approve (continuous-integration)

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2013-10-01 23:51:59 +0000
+++ launcher/Launcher.cpp	2013-10-03 15:16:29 +0000
@@ -1188,8 +1188,9 @@
 
     if (icon_under_mouse_)
       icon_under_mouse_->HideTooltip();
+
+    QueueDraw();
   }
-  QueueDraw();
 }
 
 void Launcher::OnOverlayHidden(GVariant* data)

=== modified file 'launcher/SwitcherController.cpp'
--- launcher/SwitcherController.cpp	2013-09-30 16:21:14 +0000
+++ launcher/SwitcherController.cpp	2013-10-03 15:16:29 +0000
@@ -471,10 +471,10 @@
         ResetDetailTimer(obj_->detail_timeout_length);
   });
 
-  view_->switcher_next.connect(sigc::mem_fun(this, &Controller::Impl::Next));
-  view_->switcher_prev.connect(sigc::mem_fun(this, &Controller::Impl::Prev));
-  view_->switcher_start_detail.connect(sigc::mem_fun(this, &Controller::Impl::StartDetailMode));
-  view_->switcher_stop_detail.connect(sigc::mem_fun(this, &Controller::Impl::StopDetailMode));
+  view_->switcher_next.connect(sigc::mem_fun(this, &Impl::Next));
+  view_->switcher_prev.connect(sigc::mem_fun(this, &Impl::Prev));
+  view_->switcher_start_detail.connect(sigc::mem_fun(this, &Impl::StartDetailMode));
+  view_->switcher_stop_detail.connect(sigc::mem_fun(this, &Impl::StopDetailMode));
 
   ConstructWindow();
   main_layout_->AddView(view_.GetPointer(), 1);

=== modified file 'launcher/SwitcherView.h'
--- launcher/SwitcherView.h	2013-09-30 16:21:14 +0000
+++ launcher/SwitcherView.h	2013-10-03 15:16:29 +0000
@@ -76,17 +76,17 @@
   int DetailIconIdexAt(int x, int y) const;
 
   /* void; int icon_index, int button*/
-  sigc::signal<void, int, int>  switcher_mouse_down;
-  sigc::signal<void, int, int>  switcher_mouse_up;
+  sigc::signal<void, int, int> switcher_mouse_down;
+  sigc::signal<void, int, int> switcher_mouse_up;
 
   /* void; int icon_index */
-  sigc::signal<void, int>  switcher_mouse_move;
+  sigc::signal<void, int> switcher_mouse_move;
 
   /* void; */
-  sigc::signal<void>  switcher_next;
-  sigc::signal<void>  switcher_prev;
-  sigc::signal<void>  switcher_start_detail;
-  sigc::signal<void>  switcher_stop_detail;
+  sigc::signal<void> switcher_next;
+  sigc::signal<void> switcher_prev;
+  sigc::signal<void> switcher_start_detail;
+  sigc::signal<void> switcher_stop_detail;
 
   /* void; bool visible */
   sigc::signal<void, bool> hide_request;

=== added file 'services/panel-service-private.h'
--- services/panel-service-private.h	1970-01-01 00:00:00 +0000
+++ services/panel-service-private.h	2013-10-03 15:16:29 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2013 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: Marco Trevisan <[e-mail]>
+ */
+
+#ifndef _PANEL_SERVICE_PRIVATE_H_
+#define _PANEL_SERVICE_PRIVATE_H_
+
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+
+G_BEGIN_DECLS
+
+typedef struct _KeyBinding
+{
+  KeySym key;
+  KeySym fallback;
+  guint32 modifiers;
+} KeyBinding;
+
+#define AltMask Mod1Mask
+#define SuperMask Mod4Mask
+
+void parse_string_keybinding (const char *, KeyBinding *);
+
+G_END_DECLS
+
+#endif /* _PANEL_SERVICE_PRIVATE_H_ */

=== modified file 'services/panel-service.c'
--- services/panel-service.c	2013-09-24 00:27:02 +0000
+++ services/panel-service.c	2013-10-03 15:16:29 +0000
@@ -21,6 +21,7 @@
 
 #include "config.h"
 #include "panel-service.h"
+#include "panel-service-private.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -29,8 +30,8 @@
 #include <glib/gi18n-lib.h>
 #include <libindicator/indicator-ng.h>
 
+#include <X11/XKBlib.h>
 #include <X11/extensions/XInput2.h>
-#include <X11/XKBlib.h>
 
 #include <upstart.h>
 #include <nih/alloc.h>
@@ -47,6 +48,8 @@
 #define COMPIZ_OPTION_SCHEMA "org.compiz.unityshell"
 #define COMPIZ_OPTION_PATH "/org/compiz/profiles/unity/plugins/"
 #define MENU_TOGGLE_KEYBINDING_KEY "panel-first-menu"
+#define SHOW_DASH_KEY "show-launcher"
+#define SHOW_HUD_KEY "show-hud"
 
 static PanelService *static_service = NULL;
 
@@ -62,8 +65,6 @@
   GtkWidget *menubar;
   GtkWidget *offscreen_window;
   GtkMenu *last_menu;
-  guint32  last_menu_id;
-  guint32  last_menu_move_id;
   gint32   last_x;
   gint32   last_y;
   gint     last_left;
@@ -72,9 +73,10 @@
   gint     last_bottom;
   guint32  last_menu_button;
 
-  KeyCode toggle_key;
-  guint32 toggle_modifiers;
   GSettings *gsettings;
+  KeyBinding menu_toggle;
+  KeyBinding show_dash;
+  KeyBinding show_hud;
 
   IndicatorObjectEntry *pressed_entry;
   gboolean use_event;
@@ -125,22 +127,13 @@
 };
 
 /* Forwards */
-static void load_indicator  (PanelService    *self,
-                             IndicatorObject *object,
-                             const gchar     *_name);
-static void load_indicators (PanelService    *self);
-static void load_indicators_from_indicator_files (PanelService *self);
-static void sort_indicators (PanelService    *self);
-
+static void load_indicator  (PanelService *, IndicatorObject *, const gchar *);
+static void load_indicators (PanelService *);
+static void load_indicators_from_indicator_files (PanelService *);
+static void sort_indicators (PanelService *);
 static void notify_object (IndicatorObject *object);
-
-static GdkFilterReturn event_filter (GdkXEvent    *ev,
-                                     GdkEvent     *gev,
-                                     PanelService *self);
-
-static void on_keybinding_changed (GSettings *settings,
-                                   gchar     *key,
-                                   gpointer   data);
+static void update_keybinding (GSettings *, const gchar *, gpointer);
+static GdkFilterReturn event_filter (GdkXEvent *, GdkEvent *, PanelService *);
 
 /*
  * GObject stuff
@@ -184,7 +177,8 @@
   if (GTK_IS_WIDGET (priv->last_menu) &&
       gtk_widget_get_realized (GTK_WIDGET (priv->last_menu)))
     {
-      g_object_unref (priv->last_menu);
+      gtk_menu_popdown (GTK_MENU (priv->last_menu));
+      g_signal_handlers_disconnect_by_data (priv->last_menu, self);
       priv->last_menu = NULL;
     }
 
@@ -199,7 +193,8 @@
 
   if (G_IS_OBJECT (priv->gsettings))
     {
-      g_signal_handlers_disconnect_by_func (priv->gsettings, on_keybinding_changed, self);
+      g_signal_handlers_disconnect_matched (priv->gsettings, G_SIGNAL_MATCH_FUNC,
+                                            0, 0, NULL, update_keybinding, NULL);
       g_object_unref (priv->gsettings);
       priv->gsettings = NULL;
     }
@@ -216,6 +211,8 @@
   g_hash_table_destroy (priv->panel2entries_hash);
 
   static_service = NULL;
+
+  G_OBJECT_CLASS (panel_service_parent_class)->finalize (object);
 }
 
 static void
@@ -357,6 +354,42 @@
   return entry;
 }
 
+static void
+reinject_key_event_to_root_window (XIDeviceEvent *ev)
+{
+  XKeyEvent kev;
+  kev.display = ev->display;
+  kev.window = ev->root;
+  kev.root = ev->root;
+  kev.subwindow = None;
+  kev.time = ev->time;
+  kev.x = ev->event_x;
+  kev.y = ev->event_x;
+  kev.x_root = ev->root_x;
+  kev.y_root = ev->root_y;
+  kev.same_screen = True;
+  kev.keycode = ev->detail;
+  kev.state = ev->mods.base;
+  kev.type = ev->evtype;
+
+  XSendEvent (kev.display, kev.root, True, KeyPressMask, (XEvent*) &kev);
+  XFlush (kev.display);
+}
+
+static gboolean
+event_matches_keybinding (guint32 modifiers, KeySym key, KeyBinding *kb)
+{
+  if (modifiers == kb->modifiers && key != NoSymbol)
+    {
+      if (key == kb->key || key == kb->fallback)
+        {
+          return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
 static GdkFilterReturn
 event_filter (GdkXEvent *ev, GdkEvent *gev, PanelService *self)
 {
@@ -365,41 +398,65 @@
   GdkFilterReturn ret = GDK_FILTER_CONTINUE;
 
   if (!PANEL_IS_SERVICE (self))
-  {
-    g_warning ("%s: Invalid PanelService instance", G_STRLOC);
-    return ret;
-  }
+    {
+      g_warning ("%s: Invalid PanelService instance", G_STRLOC);
+      return ret;
+    }
 
   if (!GTK_IS_WIDGET (self->priv->last_menu))
     return ret;
 
   /* Use XI2 to read the event data */
   XGenericEventCookie *cookie = &e->xcookie;
-  if (cookie->type == GenericEvent)
+  if (cookie->type != GenericEvent)
+    return ret;
+
+  XIDeviceEvent *event = cookie->data;
+  if (!event)
+    return ret;
+
+  switch (event->evtype)
     {
-      XIDeviceEvent *event = cookie->data;
-      if (!event)
-        return ret;
-
-      if (event->evtype == XI_KeyPress)
+      case XI_KeyPress:
         {
-          if (event->mods.base == priv->toggle_modifiers && event->detail == priv->toggle_key)
-          {
-            if (GTK_IS_MENU (priv->last_menu))
-              gtk_menu_popdown (GTK_MENU (priv->last_menu));
-          }
+          KeySym keysym = XkbKeycodeToKeysym (event->display, event->detail, 0, 0);
+
+          if (event_matches_keybinding (event->mods.base, keysym, &priv->menu_toggle) ||
+              event_matches_keybinding (event->mods.base, keysym, &priv->show_dash) ||
+              event_matches_keybinding (event->mods.base, keysym, &priv->show_hud))
+            {
+              if (GTK_IS_MENU (priv->last_menu))
+                gtk_menu_popdown (GTK_MENU (priv->last_menu));
+
+              ret = GDK_FILTER_REMOVE;
+            }
+          else if (event->mods.base != GDK_CONTROL_MASK)
+            {
+              if (!IsModifierKey (keysym) && (event->mods.base != 0 || keysym == XK_Print))
+                {
+                  if (GTK_IS_MENU (priv->last_menu))
+                    gtk_menu_popdown (GTK_MENU (priv->last_menu));
+
+                  reinject_key_event_to_root_window (event);
+                  ret = GDK_FILTER_REMOVE;
+                }
+            }
+
+          break;
         }
 
-      if (event->evtype == XI_ButtonPress)
+      case XI_ButtonPress:
         {
           priv->pressed_entry = get_entry_at (self, event->root_x, event->root_y);
           priv->use_event = (priv->pressed_entry == NULL);
 
           if (priv->pressed_entry)
             ret = GDK_FILTER_REMOVE;
+
+          break;
         }
 
-      if (event->evtype == XI_ButtonRelease)
+      case XI_ButtonRelease:
         {
           IndicatorObjectEntry *entry;
           gboolean event_is_a_click = FALSE;
@@ -469,6 +526,8 @@
               ret = GDK_FILTER_REMOVE;
               g_free (entry_id);
             }
+
+          break;
         }
     }
 
@@ -497,20 +556,28 @@
 }
 
 static void
-panel_service_update_menu_keybinding (PanelService *self)
-{
-  gchar *binding = g_settings_get_string (self->priv->gsettings, MENU_TOGGLE_KEYBINDING_KEY);
-
-  KeyCode keycode = 0;
-  KeySym keysym = NoSymbol;
-  guint32 modifiers = 0;
-
+update_keybinding (GSettings *settings, const gchar *key, gpointer data)
+{
+  KeyBinding *kb = data;
+  gchar *binding = g_settings_get_string (settings, key);
+  parse_string_keybinding (binding, kb);
+  g_free (binding);
+}
+
+void
+parse_string_keybinding (const char *str, KeyBinding *kb)
+{
+  kb->key = NoSymbol;
+  kb->fallback = NoSymbol;
+  kb->modifiers = 0;
+
+  gchar *binding = g_strdup (str);
   gchar *keystart = (binding) ? strrchr (binding, '>') : NULL;
 
   if (!keystart)
     keystart = binding;
 
-  while (keystart && !g_ascii_isalnum (*keystart))
+  while (keystart && *keystart != '\0' && !g_ascii_isalnum (*keystart))
     keystart++;
 
   gchar *keyend = keystart;
@@ -519,51 +586,63 @@
     keyend++;
 
   if (keystart != keyend)
-  {
-    gchar *keystr = g_strndup (keystart, keyend-keystart);
-    keysym = XStringToKeysym (keystr);
-    g_free (keystr);
-  }
-
-  if (keysym != NoSymbol)
-    {
-      Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
-      keycode = XKeysymToKeycode(dpy, keysym);
-
+    {
+      gchar *keystr = g_strndup (keystart, keyend-keystart);
+      kb->key = XStringToKeysym (keystr);
+      g_free (keystr);
+    }
+  else
+    {
+      /* Parsing the case where we only have meta-keys */
+      keyend = (binding) ? strrchr (binding, '>') : NULL;
+      keyend = keyend ? keyend - 1 : NULL;
+      keystart = keyend;
+
+      while (keystart && keystart > binding && g_ascii_isalnum (*keystart))
+        keystart--;
+
+      if (keystart != keyend)
+        {
+          gchar *keystr = g_strndup (keystart+1, keyend-keystart);
+          gchar *left = g_strconcat (keystr, "_L", NULL);
+          kb->key = XStringToKeysym (left);
+
+          gchar *right = g_strconcat (keystr, "_R", NULL);
+          kb->fallback = XStringToKeysym (right);
+          g_free (left);
+          g_free (right);
+          g_free (keystr);
+
+          keystr = g_strndup (binding, keystart-binding);
+          g_free (binding);
+          binding = keystr;
+        }
+    }
+
+  if (kb->key != NoSymbol)
+    {
       if (g_strrstr (binding, "<Shift>"))
         {
-          modifiers |= GDK_SHIFT_MASK;
+          kb->modifiers |= ShiftMask;
         }
       if (g_strrstr (binding, "<Control>") || g_strrstr (binding, "<Primary>"))
         {
-          modifiers |= GDK_CONTROL_MASK;
+          kb->modifiers |= ControlMask;
         }
       if (g_strrstr (binding, "<Alt>") || g_strrstr (binding, "<Mod1>"))
         {
-          modifiers |= GDK_MOD1_MASK;
+          kb->modifiers |= AltMask;
         }
       if (g_strrstr (binding, "<Super>"))
         {
-          modifiers |= GDK_SUPER_MASK;
+          kb->modifiers |= SuperMask;
         }
     }
 
-  self->priv->toggle_key = keycode;
-  self->priv->toggle_modifiers = modifiers;
-
   g_free (binding);
 }
 
 static void
-on_keybinding_changed (GSettings *settings, gchar *key, gpointer data)
-{
-  g_return_if_fail (PANEL_IS_SERVICE (data));
-  PanelService *self = data;
-
-  panel_service_update_menu_keybinding (self);
-}
-
-static void
 panel_service_init (PanelService *self)
 {
   PanelServicePrivate *priv;
@@ -582,15 +661,20 @@
 
   priv->gsettings = g_settings_new_with_path (COMPIZ_OPTION_SCHEMA, COMPIZ_OPTION_PATH);
   g_signal_connect (priv->gsettings, "changed::"MENU_TOGGLE_KEYBINDING_KEY,
-                    G_CALLBACK (on_keybinding_changed), self);
-
-  panel_service_update_menu_keybinding (self);
-
-  const gchar * upstartsession = g_getenv ("UPSTART_SESSION");
+                    G_CALLBACK (update_keybinding), &priv->menu_toggle);
+  g_signal_connect (priv->gsettings, "changed::"SHOW_DASH_KEY,
+                    G_CALLBACK (update_keybinding), &priv->show_dash);
+  g_signal_connect (priv->gsettings, "changed::"SHOW_HUD_KEY,
+                    G_CALLBACK (update_keybinding), &priv->show_hud);
+
+  update_keybinding (priv->gsettings, MENU_TOGGLE_KEYBINDING_KEY, &priv->menu_toggle);
+  update_keybinding (priv->gsettings, SHOW_DASH_KEY, &priv->show_dash);
+  update_keybinding (priv->gsettings, SHOW_HUD_KEY, &priv->show_hud);
+
+  const gchar *upstartsession = g_getenv ("UPSTART_SESSION");
   if (upstartsession != NULL)
     {
-      DBusConnection * conn = NULL;
-      conn = dbus_connection_open (upstartsession, NULL);
+      DBusConnection *conn = dbus_connection_open (upstartsession, NULL);
       if (conn != NULL)
         {
           priv->upstart = nih_dbus_proxy_new (NULL, conn,
@@ -603,7 +687,6 @@
 
   if (priv->upstart != NULL)
     priv->upstart->auto_start = FALSE;
-
 }
 
 static gboolean
@@ -1040,11 +1123,13 @@
                         PanelService         *self)
 {
   gchar *entry_id;
-
   g_return_if_fail (PANEL_IS_SERVICE (self));
-  if (entry == NULL)
+
+  if (!entry)
     {
-      g_warning ("on_indicator_menu_show() called with a NULL entry");
+      if (GTK_IS_MENU (self->priv->last_menu))
+        gtk_menu_popdown (GTK_MENU (self->priv->last_menu));
+
       return;
     }
 
@@ -1060,11 +1145,11 @@
                                     PanelService         *self)
 {
   gchar *entry_id;
-
   g_return_if_fail (PANEL_IS_SERVICE (self));
-  if (entry == NULL)
+
+  if (!entry)
     {
-      g_warning ("on_indicator_menu_show_now_changed() called with a NULL entry");
+      g_warning ("%s called with a NULL entry", G_STRFUNC);
       return;
     }
 
@@ -1443,12 +1528,7 @@
   priv->last_y = 0;
   priv->last_menu_button = 0;
 
-  g_signal_handler_disconnect (priv->last_menu, priv->last_menu_id);
-  g_signal_handler_disconnect (priv->last_menu, priv->last_menu_move_id);
-
   priv->last_menu = NULL;
-  priv->last_menu_id = 0;
-  priv->last_menu_move_id = 0;
   priv->last_entry = NULL;
   priv->last_left = 0;
   priv->last_right = 0;
@@ -1857,13 +1937,10 @@
       priv->last_x = 0;
       priv->last_y = 0;
 
-      g_signal_handler_disconnect (priv->last_menu, priv->last_menu_id);
-      g_signal_handler_disconnect (priv->last_menu, priv->last_menu_move_id);
+      g_signal_handlers_disconnect_by_data (priv->last_menu, self);
 
       priv->last_entry = NULL;
       priv->last_menu = NULL;
-      priv->last_menu_id = 0;
-      priv->last_menu_move_id = 0;
       priv->last_menu_button = 0;
     }
 
@@ -1905,10 +1982,9 @@
       priv->last_x = x;
       priv->last_y = y;
       priv->last_menu_button = button;
-      priv->last_menu_id = g_signal_connect (priv->last_menu, "hide",
-                                             G_CALLBACK (on_active_menu_hidden), self);
-      priv->last_menu_move_id = g_signal_connect_after (priv->last_menu, "move-current",
-                                                        G_CALLBACK (on_active_menu_move_current), self);
+      g_signal_connect (priv->last_menu, "hide", G_CALLBACK (on_active_menu_hidden), self);
+      g_signal_connect_after (priv->last_menu, "move-current",
+                              G_CALLBACK (on_active_menu_move_current), self);
 
       gtk_menu_popup (priv->last_menu, NULL, NULL, positon_menu, self, 0, CurrentTime);
       gtk_menu_reposition (priv->last_menu);

=== modified file 'tests/autopilot/unity/emulators/window_manager.py'
--- tests/autopilot/unity/emulators/window_manager.py	2012-07-04 02:37:23 +0000
+++ tests/autopilot/unity/emulators/window_manager.py	2013-10-03 15:16:29 +0000
@@ -25,6 +25,14 @@
         """Returns a tuple of (x,y,w,h) for the screen."""
         return (self.x, self.y, self.width, self.height)
 
+    def initiate_spread(self):
+        self.keybinding("spread/start")
+        self.scale_active.wait_for(True)
+
+    def terminate_spread(self):
+        self.keybinding("spread/cancel")
+        self.scale_active.wait_for(False)
+
     def enter_show_desktop(self):
         if not self.showdesktop_active:
             logger.info("Entering show desktop mode.")

=== modified file 'tests/autopilot/unity/tests/test_panel.py'
--- tests/autopilot/unity/tests/test_panel.py	2013-05-10 05:16:07 +0000
+++ tests/autopilot/unity/tests/test_panel.py	2013-10-03 15:16:29 +0000
@@ -919,7 +919,6 @@
 
         self.assertThat(self.panel.menus_shown, Eventually(Equals(False)))
 
-
     def test_menus_dont_show_with_hud(self):
         """Tests that menus are not showing when opening the HUD."""
         self.open_new_application_window("Text Editor", maximized=True)
@@ -982,6 +981,17 @@
         self.assertThat(menu_entry.menu_x, Eventually(Equals(0)))
         self.assertThat(menu_entry.menu_y, Eventually(Equals(0)))
 
+    def test_menu_closes_on_new_focused_application(self):
+        """Clicking outside an open menu must close it."""
+        menu_entry = self.open_app_and_get_menu_entry()
+        self.mouse_open_indicator(menu_entry)
+
+        # This assert is for timing purposes only:
+        self.assertThat(menu_entry.active, Eventually(Equals(True)))
+
+        self.open_new_application_window("Text Editor")
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
+
     def test_indicator_opens_when_dash_is_open(self):
         """When the dash is open and a click is on an indicator the dash
         must close and the indicator must open.
@@ -1011,9 +1021,10 @@
     def test_panel_first_menu_show_works(self):
         """Pressing the open-menus keybinding must open the first indicator."""
         self.open_new_application_window("Calculator")
-        sleep(1)
+        refresh_fn = lambda: len(self.panel.menus.get_entries())
+        self.assertThat(refresh_fn, Eventually(GreaterThan(0)))
+        self.addCleanup(self.keyboard.press_and_release, "Escape")
         self.keybinding("panel/open_first_menu")
-        self.addCleanup(self.keyboard.press_and_release, "Escape")
 
         open_indicator = self.get_active_indicator()
         expected_indicator = self.panel.get_indicator_entries(include_hidden_menus=True)[0]
@@ -1025,9 +1036,10 @@
     def test_panel_menu_accelerators_work(self):
         """Pressing a valid menu accelerator must open the correct menu item."""
         self.open_new_application_window("Text Editor")
-        sleep(1)
+        refresh_fn = lambda: len(self.panel.menus.get_entries())
+        self.assertThat(refresh_fn, Eventually(GreaterThan(0)))
+        self.addCleanup(self.keyboard.press_and_release, "Escape")
         self.keyboard.press_and_release("Alt+f")
-        self.addCleanup(self.keyboard.press_and_release, "Escape")
 
         open_indicator = self.get_active_indicator()
         self.assertThat(open_indicator.label, Eventually(Equals("_File")))

=== modified file 'tests/autopilot/unity/tests/test_spread.py'
--- tests/autopilot/unity/tests/test_spread.py	2013-05-01 00:18:11 +0000
+++ tests/autopilot/unity/tests/test_spread.py	2013-10-03 15:16:29 +0000
@@ -36,8 +36,8 @@
 
     def initiate_spread_for_screen(self):
         """Initiate the Spread for all windows"""
-        self.addCleanup(self.keybinding, "spread/cancel")
-        self.keybinding("spread/start")
+        self.addCleanup(self.unity.window_manager.terminate_spread)
+        self.unity.window_manager.initiate_spread()
         self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True)))
 
     def initiate_spread_for_application(self, desktop_id):
@@ -46,7 +46,7 @@
         self.assertThat(icon, NotEquals(None))
         launcher = self.unity.launcher.get_launcher_for_monitor(self.display.get_primary_screen())
 
-        self.addCleanup(self.keybinding, "spread/cancel")
+        self.addCleanup(self.unity.window_manager.terminate_spread)
         launcher.click_launcher_icon(icon)
         self.assertThat(self.unity.window_manager.scale_active_for_group, Eventually(Equals(True)))
 

=== modified file 'tests/autopilot/unity/tests/test_wm_keybindings.py'
--- tests/autopilot/unity/tests/test_wm_keybindings.py	2013-09-16 13:59:22 +0000
+++ tests/autopilot/unity/tests/test_wm_keybindings.py	2013-10-03 15:16:29 +0000
@@ -9,17 +9,70 @@
 from __future__ import absolute_import
 
 from autopilot.matchers import Eventually
-from testtools.matchers import Equals, NotEquals
+from testtools.matchers import Equals, NotEquals, GreaterThan
 from unity.tests import UnityTestCase
+from unity.emulators import switcher
 
 class WindowManagerKeybindings(UnityTestCase):
     """Window Manager keybindings tests"""
 
+    def setUp(self):
+        super(WindowManagerKeybindings, self).setUp()
+
+    def open_panel_menu(self):
+        panel = self.unity.panels.get_panel_for_monitor(0)
+        self.assertThat(lambda: len(panel.menus.get_entries()), Eventually(GreaterThan(0)))
+        self.addCleanup(self.keyboard.press_and_release, "Escape")
+        self.keybinding("panel/open_first_menu")
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(NotEquals(None)))
+
+    def test_dash_shows_on_menus_opened(self):
+        self.process_manager.start_app_window("Calculator")
+        self.open_panel_menu()
+        self.addCleanup(self.unity.dash.ensure_hidden)
+        self.unity.dash.ensure_visible()
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
+
+    def test_hud_shows_on_menus_opened(self):
+        self.process_manager.start_app_window("Calculator")
+        self.open_panel_menu()
+        self.addCleanup(self.unity.hud.ensure_hidden)
+        self.unity.hud.ensure_visible()
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
+
+    def test_switcher_shows_on_menus_opened(self):
+        self.process_manager.start_app_window("Calculator")
+        self.open_panel_menu()
+        self.addCleanup(self.unity.switcher.terminate)
+        self.unity.switcher.initiate()
+        self.assertProperty(self.unity.switcher, mode=switcher.SwitcherMode.NORMAL)
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
+
+    def test_shortcut_hints_shows_on_menus_opened(self):
+        self.process_manager.start_app_window("Calculator")
+        self.open_panel_menu()
+        self.addCleanup(self.unity.shortcut_hint.ensure_hidden)
+        self.unity.shortcut_hint.show()
+        self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(True)))
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
+
+    def test_spread_shows_on_menus_opened(self):
+        self.process_manager.start_app_window("Calculator")
+        self.open_panel_menu()
+        self.addCleanup(self.unity.window_manager.terminate_spread)
+        self.unity.window_manager.initiate_spread()
+        self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True)))
+        self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
+
+
+class WindowManagerKeybindingsForWindowHandling(WindowManagerKeybindings):
+    """Window Manager keybindings tests for handling a window"""
+
     scenarios = [('Restored Window', {'start_restored': True}),
                  ('Maximized Window', {'start_restored': False})]
 
     def setUp(self):
-        super(WindowManagerKeybindings, self).setUp()
+        super(WindowManagerKeybindingsForWindowHandling, self).setUp()
         self.start_test_window()
 
     def keybinding_if_not_minimized(self, keybinding):

=== modified file 'tests/data/external.gschema.xml'
--- tests/data/external.gschema.xml	2013-07-12 23:24:53 +0000
+++ tests/data/external.gschema.xml	2013-10-03 15:16:29 +0000
@@ -5,15 +5,17 @@
   <schema path="/apps/indicator-session/" id="com.canonical.indicator.session">
     <key type="b" name="suppress-logout-restart-shutdown">
       <default>false</default>
-      <summary>Suppress the dialog to confirm logout, restart and shutdown action</summary>
-      <description>Whether or not to show confirmation dialogs for logout, restart and shutdown actions.</description>
     </key>
   </schema>
   <schema id="org.compiz.unityshell" gettext-domain="compiz">
     <key type="s" name="panel-first-menu">
       <default>'&lt;Alt&gt;F10'</default>
-      <summary>Key to open the first panel menu</summary>
-      <description>Opens the first indicator menu of the Panel, allowing keyboard navigation thereafter.</description>
+    </key>
+    <key type="s" name="show-launcher">
+      <default>'&lt;Super&gt;'</default>
+    </key>
+    <key type="s" name="show-hud">
+      <default>'&lt;Alt&gt;'</default>
     </key>
    </schema>
 </schemalist>

=== modified file 'tests/test_panel_service.cpp'
--- tests/test_panel_service.cpp	2013-07-25 11:07:06 +0000
+++ tests/test_panel_service.cpp	2013-10-03 15:16:29 +0000
@@ -22,6 +22,7 @@
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/Variant.h>
 #include "panel-service.h"
+#include "panel-service-private.h"
 #include "mock_indicator_object.h"
 
 using namespace testing;
@@ -418,4 +419,134 @@
   EXPECT_TRUE(called);
 }
 
+TEST(TestPanelServiceCompizShortcutParsing, Null)
+{
+  KeyBinding kb;
+  parse_string_keybinding(NULL, &kb);
+
+  EXPECT_EQ(NoSymbol, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, Empty)
+{
+  KeyBinding kb;
+  parse_string_keybinding("", &kb);
+
+  EXPECT_EQ(NoSymbol, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, SimpleKey)
+{
+  KeyBinding kb;
+  parse_string_keybinding("U", &kb);
+
+  EXPECT_EQ(XK_U, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, ControlCombo)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Control>F1", &kb);
+
+  EXPECT_EQ(XK_F1, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(ControlMask, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, AltCombo)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Alt>F2", &kb);
+
+  EXPECT_EQ(XK_F2, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(AltMask, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, ShiftCombo)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Shift>F3", &kb);
+
+  EXPECT_EQ(XK_F3, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(ShiftMask, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, SuperCombo)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Super>F4", &kb);
+
+  EXPECT_EQ(XK_F4, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(SuperMask, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, FullCombo)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Control><Alt><Shift><Super>Escape", &kb);
+
+  EXPECT_EQ(XK_Escape, kb.key);
+  EXPECT_EQ(NoSymbol, kb.fallback);
+  EXPECT_EQ(ControlMask|AltMask|ShiftMask|SuperMask, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, MetaKeyControl)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Control>", &kb);
+
+  EXPECT_EQ(XK_Control_L, kb.key);
+  EXPECT_EQ(XK_Control_R, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, MetaKeyAlt)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Alt>", &kb);
+
+  EXPECT_EQ(XK_Alt_L, kb.key);
+  EXPECT_EQ(XK_Alt_R, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, MetaKeyShift)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Shift>", &kb);
+
+  EXPECT_EQ(XK_Shift_L, kb.key);
+  EXPECT_EQ(XK_Shift_R, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, MetaKeySuper)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Super>", &kb);
+
+  EXPECT_EQ(XK_Super_L, kb.key);
+  EXPECT_EQ(XK_Super_R, kb.fallback);
+  EXPECT_EQ(0, kb.modifiers);
+}
+
+TEST(TestPanelServiceCompizShortcutParsing, MetaKeyMix)
+{
+  KeyBinding kb;
+  parse_string_keybinding("<Control><Alt><Super>", &kb);
+
+  EXPECT_EQ(XK_Super_L, kb.key);
+  EXPECT_EQ(XK_Super_R, kb.fallback);
+  EXPECT_EQ(ControlMask|AltMask, kb.modifiers);
+}
+
 } // anonymous namespace