Merge lp:~attente/unity/enable-sound-buttons-on-lock-screen into lp:unity

[William Hua]

Enable sound buttons and input source switching under lock screen.

Enable sound buttons and input source switching under lock screen.

This depends on this MP (for the input source switching to work properly): https://code.launchpad.net/~attente/indicator-keyboard/switch-layout-on-lock/+merge/215167

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3765
http://jenkins.qa.ubuntu.com/job/unity-ci/864/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/400
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/396
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/398

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

review: Approve (continuous-integration)

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

Thanks, looks good!

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3768
http://jenkins.qa.ubuntu.com/job/unity-ci/865/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/401
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/397
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/399

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

review: Approve (continuous-integration)

=== modified file 'lockscreen/LockScreenPanel.cpp'
--- lockscreen/LockScreenPanel.cpp	2014-03-07 19:02:25 +0000
+++ lockscreen/LockScreenPanel.cpp	2014-04-10 16:49:38 +0000
@@ -21,6 +21,7 @@
 
 #include <boost/algorithm/string/trim.hpp>
 #include <Nux/HLayout.h>
+#include <UnityCore/Variant.h>
 
 #include "LockScreenSettings.h"
 #include "panel/PanelIndicatorsView.h"
@@ -38,6 +39,30 @@
 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;
@@ -49,6 +74,8 @@
   , 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();
@@ -87,6 +114,11 @@
     BuildTexture();
     QueueRelayout();
   });
+
+  ParseAccelerators();
+
+  key_down.connect(sigc::mem_fun(this, &Panel::OnKeyDown));
+  key_up.connect(sigc::mem_fun(this, &Panel::OnKeyUp));
 }
 
 void Panel::BuildTexture()
@@ -215,11 +247,211 @@
   }
 }
 
+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*)
 {
-  ActivateFirst();
   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);
+}
+
 }
 }

=== modified file 'lockscreen/LockScreenPanel.h'
--- lockscreen/LockScreenPanel.h	2014-03-06 20:51:28 +0000
+++ lockscreen/LockScreenPanel.h	2014-04-10 16:49:38 +0000
@@ -22,8 +22,10 @@
 
 #include <Nux/Nux.h>
 #include <Nux/View.h>
+#include <UnityCore/GLibDBusProxy.h>
+#include <UnityCore/GLibSource.h>
+#include <UnityCore/GLibWrapper.h>
 #include <UnityCore/Indicators.h>
-#include <UnityCore/GLibSource.h>
 #include <UnityCore/SessionManager.h>
 
 namespace unity
@@ -44,6 +46,8 @@
   nux::Property<bool> active;
   nux::Property<int> monitor;
 
+  bool WillHandleKeyEvent(unsigned int event_type, unsigned long key_sym, unsigned long modifiers);
+
 protected:
   void Draw(nux::GraphicsEngine& GfxContext, bool force_draw) override;
   bool InspectKeyEvent(unsigned int event_type, unsigned int keysym, const char*) override;
@@ -67,6 +71,52 @@
   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-09 01:11:47 +0000
+++ lockscreen/LockScreenShield.cpp	2014-04-10 16:49:38 +0000
@@ -171,20 +171,14 @@
   return prompt_view;
 }
 
-nux::Area* Shield::FindKeyFocusArea(unsigned etype, unsigned long key_code, unsigned long modifiers)
+nux::Area* Shield::FindKeyFocusArea(unsigned etype, unsigned long key_sym, unsigned long modifiers)
 {
   if (primary)
   {
-    grab_key.emit(modifiers, key_code);
-
-    if (panel_view_)
-    {
-      modifiers &= (nux::NUX_STATE_ALT | nux::NUX_STATE_CTRL | nux::NUX_STATE_SUPER | nux::NUX_STATE_SHIFT);
-      auto const& indicators_key = WindowManager::Default().activate_indicators_key();
-
-      if (indicators_key.first == modifiers && indicators_key.second == key_code)
-        return panel_view_;
-    }
+    grab_key.emit(modifiers, key_sym);
+
+    if (panel_view_ && panel_view_->WillHandleKeyEvent(etype, key_sym, modifiers))
+      return panel_view_;
 
     if (prompt_view_)
     {

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2014-04-09 19:44:08 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-04-10 16:49:38 +0000
@@ -1984,9 +1984,6 @@
     ubus_manager_.SendMessage(UBUS_OVERLAY_CLOSE_REQUEST);
   }
 
-  if (g_strcmp0(plugin, "scale") == 0)
-    g_print("Scale event %s\n",event);
-
   if (adapter.IsScaleActive() && g_strcmp0(plugin, "scale") == 0 &&
       super_keypressed_)
   {