Merge lp:~attente/unity/1291461 into lp:unity

[William Hua]

Add proper support for modifier-only shortcuts on the lock screen.

Add proper support for modifier-only shortcuts on the lock screen.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3782
http://jenkins.qa.ubuntu.com/job/unity-ci/872/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/408
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/404
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/406

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

review: Approve (continuous-integration)

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

Hey, I didn't go much into the review yet, but I was wondering: what about moving the whole thing inside a LockScreenAccelerators class, that is generated just once by LockScreenController and that the relevant LockScreenShield will pass the events to?

[William Hua (attente)]

Thanks Marco, I ripped it out like you suggested, and made it easier for us to add new accelerators if we ever need to.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3783
http://jenkins.qa.ubuntu.com/job/unity-ci/887/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/423/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/419/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/421/console

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

review: Needs Fixing (continuous-integration)

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

Cool, looks nicer!

Btw, when i meant about moving to another class, I also meant all the initialization code that now is LockScreenController. Ideally the controller should just initialize the accelerators inside Controller::LockScreen (just like it does for the indicators themselves), and would pass them to the shields.

All the parsing code should be out from the controller, and done during the Accelerators construction.

So a LockScreenAccelerators(Manager) class that handles the Accelerator's (and moving there the same functionalities that the Accelerators class has now) if you prefer :)

88 +static unsigned int KeysymToModifier(unsigned int keysym)
109 +static unsigned int KeysymToPressedMask(unsigned int keysym)
134 +static unsigned int KeysymToMirrorKeysym(unsigned int keysym)

You don't need to make them static, just put them into an anonymous namespace

560 +enum
561 +{
562 + LeftShiftPressed = 0x01,
563 + LeftControlPressed = 0x02,

Enum class would be nicer, but anyway put this into the unnamed namespace inside the .cpp file, we don't need to make this public

580 + sigc::signal<void> Activate;

Lower case names for signals please, and maybe "activated"?

314 + goto activate;

Please get rid the goto code from unity :P

618 + std::list<Accelerator> accelerators_;

Same is valid also for the code you'd move out from Lockscreen controller, but a dd a typedef for the Accelerator::Ptr class, and use smart pointers instead of using the copy, or you'd get the same object to be initialized multiple times (make them also not-copiable).

About the jenkins failure:
CRIT 2014-04-17 13:53:41 unity.glib-gio <unknown>:0 Settings schema 'org.gnome.settings-daemon.plugins.media-keys' is not installed

Just put the settings definition you need inside tests/data/external.gschema.xml or make an abstract Accelerators class.

review: Needs Fixing

[William Hua (attente)]

Thanks for the comments Marco. I made all your changes except for the goto removals. I'm hoping we can keep them because otherwise we'd end up duplicating the same code several times, and I think the label is clear enough that most people reading the code will understand what the jump does.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3784
http://jenkins.qa.ubuntu.com/job/unity-ci/890/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/426
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/422
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/424

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3786
http://jenkins.qa.ubuntu.com/job/unity-ci/902/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/438
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/434
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/436

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

review: Approve (continuous-integration)

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

Nice, awesome work...

Just one last fix, I'm not using precompiled headers here (as ccache seems to not play nicely with them), so this gives me compilation issues.

Can you just add these includes: http://paste.ubuntu.com/7362584/ ?

1095 + if (activate_panel_)
1096 + {
1097 + ActivateFirst();
1098 + activate_panel_ = false;
1099 + }

What's the reason for that?

Why not just calling ActivateFirst inside ActivatePanel (or better, replacing the content of ActivatePanel with the content of ActivateFirst, removing the latter)?
InspectKeyEvent, for the way it's used can just return always true.

From my tests I didn't notice any problem using http://pastebin.ubuntu.com/7362673/

863 + std::list<Accelerator::Ptr> accelerators_;

Really optional, but in general using std::vector works better when just iterating over elements as you do.

[William Hua (attente)]

Thanks Marco,

> 1095 + if (activate_panel_)
> 1096 + {
> 1097 + ActivateFirst();
> 1098 + activate_panel_ = false;
> 1099 + }
>
> What's the reason for that?
>
> Why not just calling ActivateFirst inside ActivatePanel (or better, replacing
> the content of ActivatePanel with the content of ActivateFirst, removing the
> latter)?
> InspectKeyEvent, for the way it's used can just return always true.
>
> From my tests I didn't notice any problem using
> http://pastebin.ubuntu.com/7362673/

I did it in that hacky way because I thought ActivateFirst would have no effect because we'd be activating it before unity::lockscreen::Shield::FindKeyFocusArea returns the panel_view_ that would receive the keyboard focus. But if your paste works fine, I'll add it, I guess I just misunderstood the way those functions work.

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

Lovely!

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3787
http://jenkins.qa.ubuntu.com/job/unity-ci/908/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/444
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/440
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/442

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

review: Approve (continuous-integration)

[William Hua (attente)]

Marco... sorry, I forgot to treat the Meta modifier as Alt so I just added it now.

=== modified file 'lockscreen/CMakeLists.txt'
--- lockscreen/CMakeLists.txt	2014-04-02 13:40:28 +0000
+++ lockscreen/CMakeLists.txt	2014-04-30 04:35:25 +0000
@@ -24,6 +24,8 @@
      LockScreenShield.cpp
      LockScreenShieldFactory.cpp
      LockScreenPanel.cpp
+     LockScreenAcceleratorController.cpp
+     LockScreenAccelerators.cpp
      ScreenSaverDBusManager.cpp
      UserAuthenticatorPam.cpp
      UserPromptView.cpp

=== modified file 'lockscreen/LockScreenAbstractShield.h'
--- lockscreen/LockScreenAbstractShield.h	2014-04-10 17:43:13 +0000
+++ lockscreen/LockScreenAbstractShield.h	2014-04-30 04:35:25 +0000
@@ -25,6 +25,7 @@
 #include <UnityCore/Indicators.h>
 
 #include "unity-shared/MockableBaseWindow.h"
+#include "LockScreenAccelerators.h"
 
 namespace unity
 {
@@ -34,12 +35,13 @@
 class AbstractShield : public MockableBaseWindow
 {
 public:
-  AbstractShield(session::Manager::Ptr const& session, indicator::Indicators::Ptr const& indicators, int monitor_num, bool is_primary)
+  AbstractShield(session::Manager::Ptr const& session, indicator::Indicators::Ptr const& indicators, Accelerators::Ptr const& accelerators, int monitor_num, bool is_primary)
     : MockableBaseWindow("Unity Lockscreen")
     , primary(is_primary)
     , monitor(monitor_num)
     , session_manager_(session)
     , indicators_(indicators)
+    , accelerators_(accelerators)
   {}
 
   nux::Property<bool> primary;
@@ -48,6 +50,7 @@
   using MockableBaseWindow::RemoveLayout;
   virtual bool IsIndicatorOpen() const = 0;
   virtual void CheckCapsLockPrompt() = 0;
+  virtual void ActivatePanel() = 0;
 
   sigc::signal<void, int, int> grab_motion;
   sigc::signal<void, unsigned long, unsigned long> grab_key;
@@ -55,6 +58,7 @@
 protected:
   session::Manager::Ptr session_manager_;
   indicator::Indicators::Ptr indicators_;
+  Accelerators::Ptr accelerators_;
 };
 
 } // lockscreen

=== added file 'lockscreen/LockScreenAcceleratorController.cpp'
--- lockscreen/LockScreenAcceleratorController.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenAcceleratorController.cpp	2014-04-30 04:35:25 +0000
@@ -0,0 +1,146 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 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: William Hua <[e-mail]>
+ */
+
+#include "LockScreenAcceleratorController.h"
+
+#include <UnityCore/GLibDBusProxy.h>
+
+namespace unity
+{
+namespace lockscreen
+{
+
+namespace
+{
+const char* const MEDIA_KEYS_SCHEMA                = "org.gnome.settings-daemon.plugins.media-keys";
+const char* const MEDIA_KEYS_KEY_VOLUME_MUTE       = "volume-mute";
+const char* const MEDIA_KEYS_KEY_VOLUME_DOWN       = "volume-down";
+const char* const MEDIA_KEYS_KEY_VOLUME_UP         = "volume-up";
+const char* const INPUT_SWITCH_SCHEMA              = "org.gnome.desktop.wm.keybindings";
+const char* const INPUT_SWITCH_KEY_PREVIOUS_SOURCE = "switch-input-source-backward";
+const char* const INPUT_SWITCH_KEY_NEXT_SOURCE     = "switch-input-source";
+
+const char* const INDICATOR_INTERFACE_ACTIONS      = "org.gtk.Actions";
+const char* const INDICATOR_METHOD_ACTIVATE        = "Activate";
+const char* const INDICATOR_SOUND_BUS_NAME         = "com.canonical.indicator.sound";
+const char* const INDICATOR_SOUND_OBJECT_PATH      = "/com/canonical/indicator/sound";
+const char* const INDICATOR_SOUND_ACTION_MUTE      = "mute";
+const char* const INDICATOR_SOUND_ACTION_SCROLL    = "scroll";
+const char* const INDICATOR_KEYBOARD_BUS_NAME      = "com.canonical.indicator.keyboard";
+const char* const INDICATOR_KEYBOARD_OBJECT_PATH   = "/com/canonical/indicator/keyboard";
+const char* const INDICATOR_KEYBOARD_ACTION_SCROLL = "locked_scroll";
+
+void ActivateIndicator(std::string const& bus_name,
+                       std::string const& object_path,
+                       std::string const& action_name,
+                       glib::Variant const& parameters = glib::Variant())
+{
+  GVariantBuilder builder;
+
+  g_variant_builder_init(&builder, G_VARIANT_TYPE("(sava{sv})"));
+  g_variant_builder_add(&builder, "s", action_name.c_str());
+
+  if (parameters)
+    g_variant_builder_add_parsed(&builder, "[%v]", static_cast<GVariant*>(parameters));
+  else
+    g_variant_builder_add_parsed(&builder, "@av []");
+
+  g_variant_builder_add_parsed(&builder, "@a{sv} []");
+
+  auto proxy = std::make_shared<glib::DBusProxy>(bus_name, object_path, INDICATOR_INTERFACE_ACTIONS);
+  proxy->CallBegin(INDICATOR_METHOD_ACTIVATE, g_variant_builder_end(&builder), [proxy] (GVariant*, glib::Error const&) {});
+}
+
+void MuteIndicatorSound()
+{
+  ActivateIndicator(INDICATOR_SOUND_BUS_NAME,
+                    INDICATOR_SOUND_OBJECT_PATH,
+                    INDICATOR_SOUND_ACTION_MUTE);
+}
+
+void ScrollIndicatorSound(int offset)
+{
+  ActivateIndicator(INDICATOR_SOUND_BUS_NAME,
+                    INDICATOR_SOUND_OBJECT_PATH,
+                    INDICATOR_SOUND_ACTION_SCROLL,
+                    g_variant_new_int32(offset));
+}
+
+void ScrollIndicatorKeyboard(int offset)
+{
+  ActivateIndicator(INDICATOR_KEYBOARD_BUS_NAME,
+                    INDICATOR_KEYBOARD_OBJECT_PATH,
+                    INDICATOR_KEYBOARD_ACTION_SCROLL,
+                    g_variant_new_int32(-offset));
+}
+} // namespace
+
+AcceleratorController::AcceleratorController()
+  : accelerators_(new Accelerators)
+{
+  auto settings = glib::Object<GSettings>(g_settings_new(MEDIA_KEYS_SCHEMA));
+
+  auto accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_MUTE)));
+  accelerator->activated.connect(std::function<void ()>(MuteIndicatorSound));
+  accelerators_->Add(accelerator);
+
+  accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_DOWN)));
+  accelerator->activated.connect(std::bind(ScrollIndicatorSound, -1));
+  accelerators_->Add(accelerator);
+
+  accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_UP)));
+  accelerator->activated.connect(std::bind(ScrollIndicatorSound, +1));
+  accelerators_->Add(accelerator);
+
+  settings = glib::Object<GSettings>(g_settings_new(INPUT_SWITCH_SCHEMA));
+
+  auto variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_PREVIOUS_SOURCE), glib::StealRef());
+
+  if (g_variant_n_children(variant) > 0)
+  {
+    const gchar* string;
+
+    g_variant_get_child(variant, 0, "&s", &string);
+
+    accelerator = std::make_shared<Accelerator>(string);
+    accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, -1));
+    accelerators_->Add(accelerator);
+  }
+
+  variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_NEXT_SOURCE), glib::StealRef());
+
+  if (g_variant_n_children(variant) > 0)
+  {
+    const gchar* string;
+
+    g_variant_get_child(variant, 0, "&s", &string);
+
+    accelerator = std::make_shared<Accelerator>(string);
+    accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, +1));
+    accelerators_->Add(accelerator);
+  }
+}
+
+Accelerators::Ptr const& AcceleratorController::GetAccelerators() const
+{
+  return accelerators_;
+}
+
+} // lockscreen namespace
+} // unity namespace

=== added file 'lockscreen/LockScreenAcceleratorController.h'
--- lockscreen/LockScreenAcceleratorController.h	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenAcceleratorController.h	2014-04-30 04:35:25 +0000
@@ -0,0 +1,46 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 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: William Hua <[e-mail]>
+ */
+
+#ifndef UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
+#define UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
+
+#include "LockScreenAccelerators.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+
+class AcceleratorController
+{
+public:
+  typedef std::shared_ptr<AcceleratorController> Ptr;
+
+  AcceleratorController();
+
+  Accelerators::Ptr const& GetAccelerators() const;
+
+private:
+  Accelerators::Ptr accelerators_;
+};
+
+} // lockscreen namespace
+} // unity namespace
+
+#endif // UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER

=== added file 'lockscreen/LockScreenAccelerators.cpp'
--- lockscreen/LockScreenAccelerators.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenAccelerators.cpp	2014-04-30 04:35:25 +0000
@@ -0,0 +1,528 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 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: William Hua <[e-mail]>
+ */
+
+#include "LockScreenAccelerators.h"
+
+#include <NuxGraphics/Events.h>
+#include <gtk/gtk.h>
+
+namespace unity
+{
+namespace lockscreen
+{
+
+enum class PressedState : unsigned int
+{
+  NothingPressed      = 0x00,
+  LeftShiftPressed    = 0x01,
+  LeftControlPressed  = 0x02,
+  LeftAltPressed      = 0x04,
+  LeftSuperPressed    = 0x08,
+  RightShiftPressed   = 0x10,
+  RightControlPressed = 0x20,
+  RightAltPressed     = 0x40,
+  RightSuperPressed   = 0x80
+};
+
+PressedState operator~(PressedState const& first)
+{
+  return static_cast<PressedState>(~static_cast<unsigned int>(first));
+}
+
+PressedState operator&(PressedState const& first, PressedState const& second)
+{
+  return static_cast<PressedState>(static_cast<unsigned int>(first) & static_cast<unsigned int>(second));
+}
+
+PressedState operator|(PressedState const& first, PressedState const& second)
+{
+  return static_cast<PressedState>(static_cast<unsigned int>(first) | static_cast<unsigned int>(second));
+}
+
+PressedState& operator&=(PressedState& first, PressedState const& second)
+{
+  return first = first & second;
+}
+
+PressedState& operator|=(PressedState& first, PressedState const& second)
+{
+  return first = first | second;
+}
+
+namespace
+{
+unsigned int KeysymToModifier(unsigned int keysym)
+{
+  switch (keysym)
+  {
+  case GDK_KEY_Shift_L:
+  case GDK_KEY_Shift_R:
+    return nux::KEY_MODIFIER_SHIFT;
+  case GDK_KEY_Control_L:
+  case GDK_KEY_Control_R:
+    return nux::KEY_MODIFIER_CTRL;
+  case GDK_KEY_Meta_L:
+  case GDK_KEY_Meta_R:
+  case GDK_KEY_Alt_L:
+  case GDK_KEY_Alt_R:
+    return nux::KEY_MODIFIER_ALT;
+  case GDK_KEY_Super_L:
+  case GDK_KEY_Super_R:
+    return nux::KEY_MODIFIER_SUPER;
+  }
+
+  return 0;
+}
+
+PressedState KeysymToPressedState(unsigned int keysym)
+{
+  switch (keysym)
+  {
+  case GDK_KEY_Shift_L:
+    return PressedState::LeftShiftPressed;
+  case GDK_KEY_Shift_R:
+    return PressedState::RightShiftPressed;
+  case GDK_KEY_Control_L:
+    return PressedState::LeftControlPressed;
+  case GDK_KEY_Control_R:
+    return PressedState::RightControlPressed;
+  case GDK_KEY_Meta_L:
+  case GDK_KEY_Alt_L:
+    return PressedState::LeftAltPressed;
+  case GDK_KEY_Meta_R:
+  case GDK_KEY_Alt_R:
+    return PressedState::RightAltPressed;
+  case GDK_KEY_Super_L:
+    return PressedState::LeftSuperPressed;
+  case GDK_KEY_Super_R:
+    return PressedState::RightSuperPressed;
+  }
+
+  return PressedState::NothingPressed;
+}
+
+unsigned int KeysymToMirrorKeysym(unsigned int keysym)
+{
+  switch (keysym)
+  {
+  case GDK_KEY_Shift_L:
+    return GDK_KEY_Shift_R;
+  case GDK_KEY_Shift_R:
+    return GDK_KEY_Shift_L;
+  case GDK_KEY_Control_L:
+    return GDK_KEY_Control_R;
+  case GDK_KEY_Control_R:
+    return GDK_KEY_Control_L;
+  case GDK_KEY_Meta_L:
+    return GDK_KEY_Meta_R;
+  case GDK_KEY_Meta_R:
+    return GDK_KEY_Meta_L;
+  case GDK_KEY_Alt_L:
+    return GDK_KEY_Alt_R;
+  case GDK_KEY_Alt_R:
+    return GDK_KEY_Alt_L;
+  case GDK_KEY_Super_L:
+    return GDK_KEY_Super_R;
+  case GDK_KEY_Super_R:
+    return GDK_KEY_Super_L;
+  }
+
+  return 0;
+}
+} // namespace
+
+Accelerator::Accelerator(unsigned int keysym,
+                         unsigned int keycode,
+                         unsigned int modifiers)
+  : keysym_(keysym)
+  , keycode_(keycode)
+  , modifiers_(modifiers)
+  , active_(true)
+  , activated_(false)
+{
+}
+
+Accelerator::Accelerator(std::string const& string)
+  : keysym_(0)
+  , keycode_(0)
+  , modifiers_(0)
+  , active_(true)
+  , activated_(false)
+{
+  guint keysym;
+  guint* keycodes;
+  GdkModifierType modifiers;
+
+  gtk_accelerator_parse_with_keycode(string.c_str(), &keysym, &keycodes, &modifiers);
+
+  /* gtk_accelerator_parse_with_keycode() might fail if the key is not in the
+   * default key map. gtk_accelerator_parse() might succeed in this case. */
+  if (keysym == 0 && keycodes == NULL && modifiers == 0)
+    gtk_accelerator_parse(string.c_str(), &keysym, &modifiers);
+
+  keysym_ = keysym;
+
+  if (keycodes != NULL)
+  {
+    keycode_ = keycodes[0];
+    g_free(keycodes);
+  }
+
+  if (modifiers & GDK_SHIFT_MASK)
+    modifiers_ |= nux::KEY_MODIFIER_SHIFT;
+  if (modifiers & GDK_CONTROL_MASK)
+    modifiers_ |= nux::KEY_MODIFIER_CTRL;
+  if ((modifiers & GDK_MOD1_MASK) || (modifiers & GDK_META_MASK))
+    modifiers_ |= nux::KEY_MODIFIER_ALT;
+  if (modifiers & GDK_SUPER_MASK)
+    modifiers_ |= nux::KEY_MODIFIER_SUPER;
+}
+
+bool Accelerator::operator==(Accelerator const& accelerator) const
+{
+  return keysym_    == accelerator.keysym_
+      && keycode_   == accelerator.keycode_
+      && modifiers_ == accelerator.modifiers_;
+}
+
+bool Accelerator::KeyPressActivate()
+{
+  activated.emit();
+  activated_ = true;
+
+  return true;
+}
+
+bool Accelerator::KeyReleaseActivate()
+{
+  activated.emit();
+  activated_ = false;
+
+  return true;
+}
+
+bool Accelerator::HandleKeyPress(unsigned int keysym,
+                                 unsigned int modifiers,
+                                 PressedState pressed_state)
+{
+  auto is_modifier_only = keysym_ == 0 && keycode_ == 0 && modifiers_ != 0;
+  auto is_modifier_keysym = KeysymToModifier(keysym_);
+  auto modifier = KeysymToModifier(keysym);
+
+  if (modifiers == 0)
+  {
+    /* We're pressing a key when no other key is pressed. We can reset this
+     * accelerator back to its original enabled state. */
+    active_ = true;
+    activated_ = false;
+  }
+
+  if (!active_)
+    return false;
+
+  /* We need to cancel modifier-only accelerators in some cases. For example,
+   * we should cancel a Ctrl+Alt accelerator if Ctrl+Alt+T is pressed. */
+  if (is_modifier_only || is_modifier_keysym)
+  {
+    if (!modifier)
+    {
+      /* We pressed a non-modifier key for a modifier-only accelerator. */
+      active_ = false;
+      return false;
+    }
+    else if (keysym != keysym_ && (modifiers_ & modifier) == 0)
+    {
+      /* We pressed a modifier key that isn't the keysym and isn't one of the
+       * modifiers. */
+      active_ = false;
+      return false;
+    }
+  }
+  else if (!modifier)
+  {
+    /* We expect a non-modifier key to activate and one was pressed. */
+    if (modifiers == modifiers_)
+    {
+      /* The modifiers match. Check if the keysyms match. */
+      if (keysym == keysym_)
+        return KeyPressActivate();
+      else
+      {
+        /* Otherwise, check if the keycodes match. Maybe the accelerator
+         * specifies a particular key code, or the keyboard layout changed. For
+         * example, if the accelerator is Ctrl+A and the user switches from a
+         * QWERTY to an AZERTY layout, we should accept Ctrl+Q so the user can
+         * cycle through the entire list of keyboard layouts. */
+
+        GdkKeymapKey* key;
+        gint keys;
+
+        if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keysym, &key, &keys))
+        {
+          for (auto i = 0; i < keys; i++)
+          {
+            if (key[i].keycode == keycode_)
+            {
+              g_free(key);
+
+              return KeyPressActivate();
+            }
+          }
+
+          g_free(key);
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+bool Accelerator::HandleKeyRelease(unsigned int keysym,
+                                   unsigned int modifiers,
+                                   PressedState pressed_state)
+{
+  auto is_modifier_only = keysym_ == 0 && keycode_ == 0 && modifiers_ != 0;
+  auto is_modifier_keysym = KeysymToModifier(keysym_);
+  auto modifier = KeysymToModifier(keysym);
+
+  /* Don't activate on key release if we were activated on a key press. */
+  if (!active_ || activated_)
+    return false;
+
+  /* Check if the keysyms match. */
+  if (keysym == keysym_)
+  {
+    if (KeysymToModifier(keysym) == 0)
+    {
+      /* We released a non-modifier key. */
+      if (modifiers == modifiers_)
+        return KeyReleaseActivate();
+    }
+    else
+    {
+      /* We released a modifier key. */
+      auto mirror_keysym = KeysymToMirrorKeysym(keysym);
+      auto is_mirror_pressed = (pressed_state & KeysymToPressedState(mirror_keysym)) != PressedState::NothingPressed;
+
+      /* Ctrl+Shift_R is different from Ctrl+Shift+Shift_R, so we must detect
+       * if the mirror key was pressed or not. */
+      if (is_mirror_pressed)
+      {
+        /* The mirrored modifier is pressed. */
+        if (modifiers == modifiers_)
+          return KeyReleaseActivate();
+      }
+      else
+      {
+        /* The mirrored modifier wasn't pressed. Compare modifiers without it. */
+        if ((modifiers & ~KeysymToModifier(mirror_keysym)) == modifiers_)
+          return KeyReleaseActivate();
+      }
+    }
+  }
+
+  if (is_modifier_only || is_modifier_keysym)
+  {
+    if (modifier)
+    {
+      /* We released a modifier key for a modifier-only accelerator. */
+
+      if (is_modifier_only)
+      {
+        /* The accelerator has no keysym or keycode. */
+
+        /* TODO: Normally we would activate here, but compiz is intercepting
+         * this case and handling it. This is bad because now we can't do
+         * anything here. Otherwise we'll do the same action twice. */
+        if (modifiers == modifiers_)
+          return false;
+      }
+      else
+      {
+        /* The accelerator has a modifier keysym. */
+        auto is_keysym_pressed = (pressed_state & KeysymToPressedState(keysym_)) != PressedState::NothingPressed;
+
+        if (is_keysym_pressed)
+        {
+          auto mirror_keysym = KeysymToMirrorKeysym(keysym_);
+          auto is_mirror_pressed = (pressed_state & KeysymToPressedState(mirror_keysym)) != PressedState::NothingPressed;
+
+          /* Ctrl+Shift_R is different from Ctrl+Shift+Shift_R, so we must detect
+           * if the mirror key was pressed or not. */
+          if (is_mirror_pressed)
+          {
+            /* The mirrored modifier is pressed. */
+            if (modifiers == modifiers_)
+              return KeyReleaseActivate();
+          }
+          else
+          {
+            /* The mirrored modifier wasn't pressed. Compare modifiers without it. */
+            if ((modifiers & ~KeysymToModifier(mirror_keysym)) == modifiers_)
+              return KeyReleaseActivate();
+          }
+        }
+      }
+    }
+  }
+  else if (keycode_ != 0 && modifiers == modifiers_)
+  {
+    /* Otherwise, check if the keycodes match. Maybe the accelerator
+     * specifies a particular key code, or the keyboard layout changed. For
+     * example, if the accelerator is Ctrl+A and the user switches from a
+     * QWERTY to an AZERTY layout, we should accept Ctrl+Q so the user can
+     * cycle through the entire list of keyboard layouts. */
+
+    GdkKeymapKey* key;
+    gint keys;
+
+    if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keysym, &key, &keys))
+    {
+      for (auto i = 0; i < keys; i++)
+      {
+        if (key[i].keycode == keycode_)
+        {
+          g_free(key);
+
+          return KeyReleaseActivate();
+        }
+      }
+
+      g_free(key);
+    }
+  }
+
+  return false;
+}
+
+Accelerators::Accelerators()
+  : pressed_state_(PressedState::NothingPressed)
+{
+}
+
+void Accelerators::Clear()
+{
+  accelerators_.clear();
+}
+
+void Accelerators::Add(Accelerator::Ptr const& accelerator)
+{
+  accelerators_.push_back(accelerator);
+}
+
+void Accelerators::Remove(Accelerator::Ptr const& accelerator)
+{
+  accelerators_.erase(std::remove(accelerators_.begin(), accelerators_.end(), accelerator), accelerators_.end());
+}
+
+bool Accelerators::HandleKeyPress(unsigned int keysym,
+                                  unsigned int modifiers)
+{
+  modifiers &= nux::KEY_MODIFIER_SHIFT
+             | nux::KEY_MODIFIER_CTRL
+             | nux::KEY_MODIFIER_ALT
+             | nux::KEY_MODIFIER_SUPER;
+
+  switch (keysym)
+  {
+  case GDK_KEY_Shift_L:
+    pressed_state_ |= PressedState::LeftShiftPressed;
+    break;
+  case GDK_KEY_Shift_R:
+    pressed_state_ |= PressedState::RightShiftPressed;
+    break;
+  case GDK_KEY_Control_L:
+    pressed_state_ |= PressedState::LeftControlPressed;
+    break;
+  case GDK_KEY_Control_R:
+    pressed_state_ |= PressedState::RightControlPressed;
+    break;
+  case GDK_KEY_Meta_L:
+  case GDK_KEY_Alt_L:
+    pressed_state_ |= PressedState::LeftAltPressed;
+    break;
+  case GDK_KEY_Meta_R:
+  case GDK_KEY_Alt_R:
+    pressed_state_ |= PressedState::RightAltPressed;
+    break;
+  case GDK_KEY_Super_L:
+    pressed_state_ |= PressedState::LeftSuperPressed;
+    break;
+  case GDK_KEY_Super_R:
+    pressed_state_ |= PressedState::RightSuperPressed;
+    break;
+  }
+
+  auto handled = false;
+
+  for (auto& accelerator : accelerators_)
+    handled = accelerator->HandleKeyPress(keysym, modifiers, pressed_state_) || handled;
+
+  return handled;
+}
+
+bool Accelerators::HandleKeyRelease(unsigned int keysym,
+                                    unsigned int modifiers)
+{
+  modifiers &= nux::KEY_MODIFIER_SHIFT
+             | nux::KEY_MODIFIER_CTRL
+             | nux::KEY_MODIFIER_ALT
+             | nux::KEY_MODIFIER_SUPER;
+
+  auto handled = false;
+
+  for (auto& accelerator : accelerators_)
+    handled = accelerator->HandleKeyRelease(keysym, modifiers, pressed_state_) || handled;
+
+  switch (keysym)
+  {
+  case GDK_KEY_Shift_L:
+    pressed_state_ &= ~PressedState::LeftShiftPressed;
+    break;
+  case GDK_KEY_Shift_R:
+    pressed_state_ &= ~PressedState::RightShiftPressed;
+    break;
+  case GDK_KEY_Control_L:
+    pressed_state_ &= ~PressedState::LeftControlPressed;
+    break;
+  case GDK_KEY_Control_R:
+    pressed_state_ &= ~PressedState::RightControlPressed;
+    break;
+  case GDK_KEY_Meta_L:
+  case GDK_KEY_Alt_L:
+    pressed_state_ &= ~PressedState::LeftAltPressed;
+    break;
+  case GDK_KEY_Meta_R:
+  case GDK_KEY_Alt_R:
+    pressed_state_ &= ~PressedState::RightAltPressed;
+    break;
+  case GDK_KEY_Super_L:
+    pressed_state_ &= ~PressedState::LeftSuperPressed;
+    break;
+  case GDK_KEY_Super_R:
+    pressed_state_ &= ~PressedState::RightSuperPressed;
+    break;
+  }
+
+  return handled;
+}
+
+} // lockscreen namespace
+} // unity namespace

=== added file 'lockscreen/LockScreenAccelerators.h'
--- lockscreen/LockScreenAccelerators.h	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenAccelerators.h	2014-04-30 04:35:25 +0000
@@ -0,0 +1,92 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 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: William Hua <[e-mail]>
+ */
+
+#ifndef UNITY_LOCKSCREEN_ACCELERATORS
+#define UNITY_LOCKSCREEN_ACCELERATORS
+
+#include <memory>
+#include <sigc++/signal.h>
+
+namespace unity
+{
+namespace lockscreen
+{
+
+enum class PressedState : unsigned int;
+
+class Accelerator
+{
+public:
+  typedef std::shared_ptr<Accelerator> Ptr;
+
+  Accelerator(unsigned int keysym, unsigned int keycode, unsigned int modifiers);
+  explicit Accelerator(std::string const& string);
+
+  bool operator==(Accelerator const& accelerator) const;
+
+  sigc::signal<void> activated;
+
+private:
+  bool KeyPressActivate();
+  bool KeyReleaseActivate();
+
+  bool HandleKeyPress(unsigned int keysym,
+                      unsigned int modifiers,
+                      PressedState pressed_state);
+  bool HandleKeyRelease(unsigned int keysym,
+                        unsigned int modifiers,
+                        PressedState pressed_state);
+
+  unsigned int keysym_;
+  unsigned int keycode_;
+  unsigned int modifiers_;
+
+  bool active_;
+  bool activated_;
+
+  friend class Accelerators;
+};
+
+class Accelerators
+{
+public:
+  typedef std::shared_ptr<Accelerators> Ptr;
+
+  Accelerators();
+
+  void Clear();
+
+  void Add(Accelerator::Ptr const& accelerator);
+  void Remove(Accelerator::Ptr const& accelerator);
+
+  bool HandleKeyPress(unsigned int keysym,
+                      unsigned int modifiers);
+  bool HandleKeyRelease(unsigned int keysym,
+                        unsigned int modifiers);
+
+private:
+  std::vector<Accelerator::Ptr> accelerators_;
+
+  PressedState pressed_state_;
+};
+
+} // lockscreen namespace
+} // unity namespace
+
+#endif // UNITY_LOCKSCREEN_ACCELERATORS

=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2014-04-11 07:26:11 +0000
+++ lockscreen/LockScreenController.cpp	2014-04-30 04:35:25 +0000
@@ -107,6 +107,7 @@
       shields_.clear();
 
       upstart_wrapper_->Emit("desktop-unlock");
+      accelerator_controller_.reset();
       indicators_.reset();
     }
     else if (!prompt_activation_)
@@ -141,6 +142,12 @@
   });
 }
 
+void Controller::ActivatePanel()
+{
+  if (primary_shield_.IsValid())
+    primary_shield_->ActivatePanel();
+}
+
 void Controller::ResetPostLockScreenSaver()
 {
   screensaver_post_lock_timeout_.reset();
@@ -186,7 +193,7 @@
 
     if (i >= shields_size)
     {
-      shield = shield_factory_->CreateShield(session_manager_, indicators_, i, i == primary);
+      shield = shield_factory_->CreateShield(session_manager_, indicators_, accelerator_controller_->GetAccelerators(), i, i == primary);
       is_new = true;
     }
 
@@ -390,6 +397,12 @@
   indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
   upstart_wrapper_->Emit("desktop-lock");
 
+  accelerator_controller_ = std::make_shared<AcceleratorController>();
+  auto activate_key = WindowManager::Default().activate_indicators_key();
+  auto accelerator = std::make_shared<Accelerator>(activate_key.second, 0, activate_key.first);
+  accelerator->activated.connect(std::bind(std::mem_fn(&Controller::ActivatePanel), this));
+  accelerator_controller_->GetAccelerators()->Add(accelerator);
+
   ShowShields();
 }
 

=== modified file 'lockscreen/LockScreenController.h'
--- lockscreen/LockScreenController.h	2014-04-10 06:36:43 +0000
+++ lockscreen/LockScreenController.h	2014-04-30 04:35:25 +0000
@@ -25,6 +25,7 @@
 #include <UnityCore/GLibSource.h>
 
 #include "LockScreenShieldFactory.h"
+#include "LockScreenAcceleratorController.h"
 #include "ScreenSaverDBusManager.h"
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/UpstartWrapper.h"
@@ -60,6 +61,7 @@
   void BlankWindowGrabEnable(bool grab);
   void SimulateActivity();
   void ResetPostLockScreenSaver();
+  void ActivatePanel();
 
   void OnLockRequested(bool prompt);
   void OnUnlockRequested();
@@ -74,6 +76,7 @@
   DBusManager::Ptr dbus_manager_;
   session::Manager::Ptr session_manager_;
   indicator::Indicators::Ptr indicators_;
+  AcceleratorController::Ptr accelerator_controller_;
   UpstartWrapper::Ptr upstart_wrapper_;
   ShieldFactoryInterface::Ptr shield_factory_;
 
@@ -98,4 +101,4 @@
 }
 }
 
-#endif
\ No newline at end of file
+#endif

=== modified file 'lockscreen/LockScreenPanel.cpp'
--- lockscreen/LockScreenPanel.cpp	2014-04-10 16:49:05 +0000
+++ lockscreen/LockScreenPanel.cpp	2014-04-30 04:35:25 +0000
@@ -21,7 +21,6 @@
 
 #include <boost/algorithm/string/trim.hpp>
 #include <Nux/HLayout.h>
-#include <UnityCore/Variant.h>
 
 #include "LockScreenSettings.h"
 #include "panel/PanelIndicatorsView.h"
@@ -39,30 +38,6 @@
 namespace
 {
 const RawPixel PADDING = 5_em;
-
-const std::string MEDIA_KEYS_SCHEMA      = "org.gnome.settings-daemon.plugins.media-keys";
-const std::string MEDIA_KEYS_VOLUME_MUTE = "volume-mute";
-const std::string MEDIA_KEYS_VOLUME_DOWN = "volume-down";
-const std::string MEDIA_KEYS_VOLUME_UP   = "volume-up";
-const std::string INPUT_SWITCH_SCHEMA    = "org.gnome.desktop.wm.keybindings";
-const std::string INPUT_SWITCH_PREVIOUS  = "switch-input-source-backward";
-const std::string INPUT_SWITCH_NEXT      = "switch-input-source";
-
-const std::string INDICATOR_KEYBOARD_BUS_NAME    = "com.canonical.indicator.keyboard";
-const std::string INDICATOR_KEYBOARD_OBJECT_PATH = "/com/canonical/indicator/keyboard";
-const std::string INDICATOR_SOUND_BUS_NAME       = "com.canonical.indicator.sound";
-const std::string INDICATOR_SOUND_OBJECT_PATH    = "/com/canonical/indicator/sound";
-const std::string INDICATOR_ACTION_INTERFACE     = "org.gtk.Actions";
-
-const std::string INDICATOR_KEYBOARD_ACTION_SCROLL = "locked_scroll";
-const std::string INDICATOR_SOUND_ACTION_SCROLL    = "scroll";
-const std::string INDICATOR_SOUND_ACTION_MUTE      = "mute";
-
-const unsigned int MODIFIERS = nux::KEY_MODIFIER_SHIFT |
-                               nux::KEY_MODIFIER_CAPS_LOCK |
-                               nux::KEY_MODIFIER_CTRL |
-                               nux::KEY_MODIFIER_ALT |
-                               nux::KEY_MODIFIER_SUPER;
 }
 
 using namespace indicator;
@@ -74,8 +49,6 @@
   , monitor(monitor_)
   , indicators_(indicators)
   , needs_geo_sync_(true)
-  , media_key_settings_(g_settings_new(MEDIA_KEYS_SCHEMA.c_str()))
-  , input_switch_settings_(g_settings_new(INPUT_SWITCH_SCHEMA.c_str()))
 {
   double scale = unity::Settings::Instance().em(monitor)->DPIScale();
   auto* layout = new nux::HLayout();
@@ -114,11 +87,6 @@
     BuildTexture();
     QueueRelayout();
   });
-
-  ParseAccelerators();
-
-  key_down.connect(sigc::mem_fun(this, &Panel::OnKeyDown));
-  key_up.connect(sigc::mem_fun(this, &Panel::OnKeyUp));
 }
 
 void Panel::BuildTexture()
@@ -180,12 +148,6 @@
     indicators_view_->ActivateEntry(entry_id, 0);
 }
 
-void Panel::ActivateFirst()
-{
-  if (GetInputEventSensitivity())
-    indicators_view_->ActivateIfSensitive();
-}
-
 void Panel::OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const&)
 {
   if (!GetInputEventSensitivity() || (!panel.empty() && panel != GetPanelName()))
@@ -247,210 +209,15 @@
   }
 }
 
-Panel::Accelerator Panel::ParseAcceleratorString(std::string const& string) const
-{
-  guint gtk_key;
-  GdkModifierType gtk_modifiers;
-  gtk_accelerator_parse(string.c_str(), &gtk_key, &gtk_modifiers);
-
-  unsigned int nux_key = gtk_key;
-  unsigned int nux_modifiers = 0;
-
-  if (gtk_modifiers & GDK_SHIFT_MASK)
-    nux_modifiers |= nux::KEY_MODIFIER_SHIFT;
-  if (gtk_modifiers & GDK_LOCK_MASK)
-    nux_modifiers |= nux::KEY_MODIFIER_CAPS_LOCK;
-  if (gtk_modifiers & GDK_CONTROL_MASK)
-    nux_modifiers |= nux::KEY_MODIFIER_CTRL;
-  if (gtk_modifiers & GDK_MOD1_MASK)
-    nux_modifiers |= nux::KEY_MODIFIER_ALT;
-  if (gtk_modifiers & GDK_SUPER_MASK)
-    nux_modifiers |= nux::KEY_MODIFIER_SUPER;
-
-  return std::make_pair(nux_modifiers, nux_key);
-}
-
-void Panel::ParseAccelerators()
-{
-  activate_indicator_ = WindowManager::Default().activate_indicators_key();
-  volume_mute_ = ParseAcceleratorString(glib::String(g_settings_get_string(media_key_settings_, MEDIA_KEYS_VOLUME_MUTE.c_str())));
-  volume_down_ = ParseAcceleratorString(glib::String(g_settings_get_string(media_key_settings_, MEDIA_KEYS_VOLUME_DOWN.c_str())));
-  volume_up_ = ParseAcceleratorString(glib::String(g_settings_get_string(media_key_settings_, MEDIA_KEYS_VOLUME_UP.c_str())));
-
-  auto variant = glib::Variant(g_settings_get_value(input_switch_settings_, INPUT_SWITCH_PREVIOUS.c_str()), glib::StealRef());
-
-  if (g_variant_n_children(variant) > 0)
-  {
-    const gchar *accelerator;
-    g_variant_get_child(variant, 0, "&s", &accelerator);
-    previous_source_ = ParseAcceleratorString(accelerator);
-  }
-  else
-    previous_source_ = std::make_pair(0, 0);
-
-  variant = glib::Variant(g_settings_get_value(input_switch_settings_, INPUT_SWITCH_NEXT.c_str()), glib::StealRef());
-
-  if (g_variant_n_children(variant) > 0)
-  {
-    const gchar *accelerator;
-    g_variant_get_child(variant, 0, "&s", &accelerator);
-    next_source_ = ParseAcceleratorString(accelerator);
-  }
-  else
-    next_source_ = std::make_pair(0, 0);
-}
-
-bool Panel::WillHandleKeyEvent(unsigned int event_type, unsigned long key_sym, unsigned long modifiers)
-{
-  auto is_press = event_type == nux::EVENT_KEY_DOWN;
-
-  /* If we're just pressing a key, and no modifiers are pressed, then
-   * we can start accepting new actions again. */
-  if (is_press && (modifiers & MODIFIERS) == 0)
-    last_action_ = std::make_pair(0, 0);
-
-  return IsMatch(is_press, key_sym, modifiers, activate_indicator_) ||
-         IsMatch(is_press, key_sym, modifiers, volume_mute_) ||
-         IsMatch(is_press, key_sym, modifiers, volume_down_) ||
-         IsMatch(is_press, key_sym, modifiers, volume_up_) ||
-         IsMatch(is_press, key_sym, modifiers, previous_source_) ||
-         IsMatch(is_press, key_sym, modifiers, next_source_);
-}
-
 bool Panel::InspectKeyEvent(unsigned int event_type, unsigned int keysym, const char*)
 {
   return true;
 }
 
-bool Panel::IsMatch(bool is_press,
-                    unsigned int key_sym,
-                    unsigned int state,
-                    Accelerator const& accelerator) const
-{
-  /* Do the easy check, just compare key codes and modifiers.
-   * TODO: Check permutations of modifier-only shortcuts. */
-  return key_sym == accelerator.second && (state & MODIFIERS) == accelerator.first;
-}
-
-void Panel::OnKeyDown(unsigned long event,
-                      unsigned long key_sym,
-                      unsigned long state,
-                      const char* text,
-                      unsigned short repeat)
-{
-  if (IsMatch(true, key_sym, state, activate_indicator_))
-  {
-    ActivateFirst();
-    last_action_ = activate_indicator_;
-  }
-  else if (IsMatch(true, key_sym, state, volume_mute_))
-  {
-    ActivateSoundAction(INDICATOR_SOUND_ACTION_MUTE);
-    last_action_ = volume_mute_;
-  }
-  else if (IsMatch(true, key_sym, state, volume_down_))
-  {
-    ActivateSoundAction(INDICATOR_SOUND_ACTION_SCROLL, g_variant_new_int32(-1));
-    last_action_ = volume_down_;
-  }
-  else if (IsMatch(true, key_sym, state, volume_up_))
-  {
-    ActivateSoundAction(INDICATOR_SOUND_ACTION_SCROLL, g_variant_new_int32(+1));
-    last_action_ = volume_up_;
-  }
-  else if (IsMatch(true, key_sym, state, previous_source_))
-  {
-    ActivateKeyboardAction(INDICATOR_KEYBOARD_ACTION_SCROLL, g_variant_new_int32(-1));
-    last_action_ = previous_source_;
-  }
-  else if (IsMatch(true, key_sym, state, next_source_))
-  {
-    ActivateKeyboardAction(INDICATOR_KEYBOARD_ACTION_SCROLL, g_variant_new_int32(+1));
-    last_action_ = next_source_;
-  }
-}
-
-void Panel::OnKeyUp(unsigned int key_sym,
-                    unsigned long key_code,
-                    unsigned long state)
-{
-  /* We only want to act if we didn't activate the action on key
-   * down. Once we see the key up, we can start accepting actions
-   * again. */
-
-  if (IsMatch(false, key_sym, state, activate_indicator_))
-  {
-    if (last_action_ != activate_indicator_)
-      ActivateFirst();
-
-    last_action_ = std::make_pair(0, 0);
-  }
-  else if (IsMatch(false, key_sym, state, volume_mute_))
-  {
-    if (last_action_ != volume_mute_)
-      ActivateSoundAction(INDICATOR_SOUND_ACTION_MUTE);
-
-    last_action_ = std::make_pair(0, 0);
-  }
-  else if (IsMatch(false, key_sym, state, volume_down_))
-  {
-    if (last_action_ != volume_down_)
-      ActivateSoundAction(INDICATOR_SOUND_ACTION_SCROLL, g_variant_new_int32(-1));
-
-    last_action_ = std::make_pair(0, 0);
-  }
-  else if (IsMatch(false, key_sym, state, volume_up_))
-  {
-    if (last_action_ != volume_up_)
-      ActivateSoundAction(INDICATOR_SOUND_ACTION_SCROLL, g_variant_new_int32(+1));
-
-    last_action_ = std::make_pair(0, 0);
-  }
-  else if (IsMatch(false, key_sym, state, previous_source_))
-  {
-    if (last_action_ != previous_source_)
-      ActivateKeyboardAction(INDICATOR_KEYBOARD_ACTION_SCROLL, g_variant_new_int32(-1));
-
-    last_action_ = std::make_pair(0, 0);
-  }
-  else if (IsMatch(false, key_sym, state, next_source_))
-  {
-    if (last_action_ != next_source_)
-      ActivateKeyboardAction(INDICATOR_KEYBOARD_ACTION_SCROLL, g_variant_new_int32(+1));
-
-    last_action_ = std::make_pair(0, 0);
-  }
-}
-
-void Panel::ActivateIndicatorAction(std::string const& bus_name,
-                                    std::string const& object_path,
-                                    std::string const& action,
-                                    glib::Variant const& parameter) const
-{
-  GVariantBuilder builder;
-
-  g_variant_builder_init(&builder, G_VARIANT_TYPE("(sava{sv})"));
-  g_variant_builder_add(&builder, "s", action.c_str());
-
-  if (parameter)
-    g_variant_builder_add_parsed(&builder, "[%v]", (GVariant*) parameter);
-  else
-    g_variant_builder_add_parsed(&builder, "@av []");
-
-  g_variant_builder_add_parsed(&builder, "@a{sv} []");
-
-  auto proxy = std::make_shared<glib::DBusProxy>(bus_name, object_path, INDICATOR_ACTION_INTERFACE, G_BUS_TYPE_SESSION);
-  proxy->CallBegin("Activate", g_variant_builder_end(&builder), [proxy] (GVariant*, glib::Error const&) {});
-}
-
-void Panel::ActivateKeyboardAction(std::string const& action, glib::Variant const& parameter) const
-{
-  ActivateIndicatorAction(INDICATOR_KEYBOARD_BUS_NAME, INDICATOR_KEYBOARD_OBJECT_PATH, action, parameter);
-}
-
-void Panel::ActivateSoundAction(std::string const& action, glib::Variant const& parameter) const
-{
-  ActivateIndicatorAction(INDICATOR_SOUND_BUS_NAME, INDICATOR_SOUND_OBJECT_PATH, action, parameter);
+void Panel::ActivatePanel()
+{
+  if (GetInputEventSensitivity())
+    indicators_view_->ActivateIfSensitive();
 }
 
 }

=== modified file 'lockscreen/LockScreenPanel.h'
--- lockscreen/LockScreenPanel.h	2014-04-10 16:23:49 +0000
+++ lockscreen/LockScreenPanel.h	2014-04-30 04:35:25 +0000
@@ -22,10 +22,8 @@
 
 #include <Nux/Nux.h>
 #include <Nux/View.h>
-#include <UnityCore/GLibDBusProxy.h>
+#include <UnityCore/Indicators.h>
 #include <UnityCore/GLibSource.h>
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/Indicators.h>
 #include <UnityCore/SessionManager.h>
 
 namespace unity
@@ -46,7 +44,7 @@
   nux::Property<bool> active;
   nux::Property<int> monitor;
 
-  bool WillHandleKeyEvent(unsigned int event_type, unsigned long key_sym, unsigned long modifiers);
+  void ActivatePanel();
 
 protected:
   void Draw(nux::GraphicsEngine& GfxContext, bool force_draw) override;
@@ -71,52 +69,6 @@
   bool needs_geo_sync_;
   nux::Point tracked_pointer_pos_;
   glib::Source::UniquePtr track_menu_pointer_timeout_;
-
-  glib::Object<GSettings> media_key_settings_;
-  glib::Object<GSettings> input_switch_settings_;
-
-  typedef std::pair<unsigned int, unsigned int> Accelerator;
-  Accelerator ParseAcceleratorString(std::string const& string) const;
-
-  void ParseAccelerators();
-
-  Accelerator activate_indicator_;
-  Accelerator volume_mute_;
-  Accelerator volume_down_;
-  Accelerator volume_up_;
-  Accelerator previous_source_;
-  Accelerator next_source_;
-
-  /* We only want to activate the indicator on key press OR key
-   * release, never both, so we'll need to keep track of the last
-   * action that occurred. However, holding the keys down should
-   * allow multiple activations, for example, when the volume
-   * down button is held down. */
-  Accelerator last_action_;
-
-  bool IsMatch(bool is_press,
-               unsigned int key_sym,
-               unsigned int modifiers,
-               Accelerator const& accelerator) const;
-
-  void OnKeyDown(unsigned long event,
-                 unsigned long key_sym,
-                 unsigned long state,
-                 const char* text,
-                 unsigned short repeat);
-
-  void OnKeyUp(unsigned int key_sym,
-               unsigned long key_code,
-               unsigned long state);
-
-  /* This is just for telling an indicator to do something. */
-  void ActivateIndicatorAction(std::string const& bus_name,
-                               std::string const& object_path,
-                               std::string const& action,
-                               glib::Variant const& parameter = glib::Variant()) const;
-
-  void ActivateKeyboardAction(std::string const& action, glib::Variant const& parameter = glib::Variant()) const;
-  void ActivateSoundAction(std::string const& action, glib::Variant const& parameter = glib::Variant()) const;
 };
 
 } // lockscreen namespace

=== modified file 'lockscreen/LockScreenShield.cpp'
--- lockscreen/LockScreenShield.cpp	2014-04-10 17:43:34 +0000
+++ lockscreen/LockScreenShield.cpp	2014-04-30 04:35:25 +0000
@@ -36,8 +36,8 @@
 namespace lockscreen
 {
 
-Shield::Shield(session::Manager::Ptr const& session_manager, indicator::Indicators::Ptr const& indicators, int monitor_num, bool is_primary)
-  : AbstractShield(session_manager, indicators, monitor_num, is_primary)
+Shield::Shield(session::Manager::Ptr const& session_manager, indicator::Indicators::Ptr const& indicators, Accelerators::Ptr const& accelerators, int monitor_num, bool is_primary)
+  : AbstractShield(session_manager, indicators, accelerators, monitor_num, is_primary)
   , bg_settings_(std::make_shared<BackgroundSettings>())
   , prompt_view_(nullptr)
   , panel_view_(nullptr)
@@ -177,14 +177,25 @@
   return prompt_view;
 }
 
-nux::Area* Shield::FindKeyFocusArea(unsigned etype, unsigned long key_sym, unsigned long modifiers)
+nux::Area* Shield::FindKeyFocusArea(unsigned etype, unsigned long keysym, unsigned long modifiers)
 {
   if (primary)
   {
-    grab_key.emit(modifiers, key_sym);
+    grab_key.emit(modifiers, keysym);
 
-    if (panel_view_ && panel_view_->WillHandleKeyEvent(etype, key_sym, modifiers))
-      return panel_view_;
+    if (accelerators_)
+    {
+      if (etype == nux::EVENT_KEY_DOWN)
+      {
+        if (accelerators_->HandleKeyPress(keysym, modifiers))
+          return panel_view_;
+      }
+      else if (etype == nux::EVENT_KEY_UP)
+      {
+        if (accelerators_->HandleKeyRelease(keysym, modifiers))
+          return panel_view_;
+      }
+    }
 
     if (prompt_view_)
     {
@@ -218,5 +229,11 @@
   return panel_view_ ? panel_view_->active() : false;
 }
 
+void Shield::ActivatePanel()
+{
+  if (panel_view_)
+    panel_view_->ActivatePanel();
+}
+
 }
 }

=== modified file 'lockscreen/LockScreenShield.h'
--- lockscreen/LockScreenShield.h	2014-04-09 17:09:18 +0000
+++ lockscreen/LockScreenShield.h	2014-04-30 04:35:25 +0000
@@ -36,10 +36,11 @@
 class Shield : public AbstractShield
 {
 public:
-  Shield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, int monitor, bool is_primary);
+  Shield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, Accelerators::Ptr const&, int monitor, bool is_primary);
 
   bool IsIndicatorOpen() const override;
   void CheckCapsLockPrompt() override;
+  void ActivatePanel() override;
 
 protected:
   bool AcceptKeyNavFocus() override;

=== modified file 'lockscreen/LockScreenShieldFactory.cpp'
--- lockscreen/LockScreenShieldFactory.cpp	2014-03-07 18:35:10 +0000
+++ lockscreen/LockScreenShieldFactory.cpp	2014-04-30 04:35:25 +0000
@@ -25,9 +25,9 @@
 namespace lockscreen
 {
 
-nux::ObjectPtr<AbstractShield> ShieldFactory::CreateShield(session::Manager::Ptr const& session_manager, indicator::Indicators::Ptr const& indicators, int monitor, bool is_primary)
+nux::ObjectPtr<AbstractShield> ShieldFactory::CreateShield(session::Manager::Ptr const& session_manager, indicator::Indicators::Ptr const& indicators, Accelerators::Ptr const& accelerators, int monitor, bool is_primary)
 {
-  return nux::ObjectPtr<Shield>(new Shield(session_manager, indicators, monitor, is_primary));
+  return nux::ObjectPtr<Shield>(new Shield(session_manager, indicators, accelerators, monitor, is_primary));
 }
 
 }

=== modified file 'lockscreen/LockScreenShieldFactory.h'
--- lockscreen/LockScreenShieldFactory.h	2014-03-07 18:35:10 +0000
+++ lockscreen/LockScreenShieldFactory.h	2014-04-30 04:35:25 +0000
@@ -37,12 +37,12 @@
 
   virtual ~ShieldFactoryInterface() = default;
 
-  virtual nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, int monitor, bool is_primary) = 0;
+  virtual nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, Accelerators::Ptr const&, int monitor, bool is_primary) = 0;
 };
 
 struct ShieldFactory : ShieldFactoryInterface
 {
-  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, int monitor, bool is_primary) override;
+  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, Accelerators::Ptr const&, int monitor, bool is_primary) override;
 };
 
 }

=== modified file 'tests/data/external.gschema.xml'
--- tests/data/external.gschema.xml	2014-04-08 22:45:07 +0000
+++ tests/data/external.gschema.xml	2014-04-30 04:35:25 +0000
@@ -121,4 +121,25 @@
       <default>false</default>
     </key>
   </schema>
+
+  <schema id="org.gnome.settings-daemon.plugins.media-keys" path="/org/gnome/settings-daemon/plugins/media-keys/">
+    <key type="s" name="volume-mute">
+      <default>'XF86AudioMute'</default>
+    </key>
+    <key type="s" name="volume-down">
+      <default>'XF86AudioLowerVolume'</default>
+    </key>
+    <key type="s" name="volume-up">
+      <default>'XF86AudioRaiseVolume'</default>
+    </key>
+  </schema>
+
+  <schema id="org.gnome.desktop.wm.keybindings" path="/org/gnome/desktop/wm/keybindings/">
+    <key type="as" name="switch-input-source-backward">
+      <default>["&lt;Shift&gt;&lt;Super&gt;space"]</default>
+    </key>
+    <key type="as" name="switch-input-source">
+      <default>["&lt;Super&gt;space"]</default>
+    </key>
+  </schema>
 </schemalist>

=== modified file 'tests/test_lockscreen_controller.cpp'
--- tests/test_lockscreen_controller.cpp	2014-04-11 07:26:11 +0000
+++ tests/test_lockscreen_controller.cpp	2014-04-30 04:35:25 +0000
@@ -52,16 +52,17 @@
 struct MockShield : AbstractShield
 {
   MockShield()
-    : AbstractShield(nullptr, nullptr, 0, false)
+    : AbstractShield(nullptr, nullptr, nullptr, 0, false)
   {}
 
   MOCK_CONST_METHOD0(IsIndicatorOpen, bool());
   MOCK_METHOD0(CheckCapsLockPrompt, void());
+  MOCK_METHOD0(ActivatePanel, void());
 };
 
 struct ShieldFactoryMock : ShieldFactoryInterface
 {
-  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, int, bool) override
+  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&, Accelerators::Ptr const&, int, bool) override
   {
     return nux::ObjectPtr<AbstractShield>(new MockShield());
   }