Merge lp:~3v1n0/unity/dash-invalid-keys-filter-5.0 into lp:unity/5.0

[Marco Trevisan (Treviño)]

DashView: filter out the unprintable keys when focusing the search bar

The search bar can't be focused when invalid keys (such as shift, ctrl, F1...) are pressed.

Backported lp:~3v1n0/unity/dash-invalid-keys-filter to 5.0 branch

[Andrea Azzarone (azzar1)]

+1

review: Approve

=== modified file 'plugins/unityshell/src/DashView.cpp'
--- plugins/unityshell/src/DashView.cpp	2012-04-24 08:20:00 +0000
+++ plugins/unityshell/src/DashView.cpp	2012-06-28 17:26:31 +0000
@@ -32,6 +32,7 @@
 #include "DashStyle.h"
 #include "DashSettings.h"
 #include "UBusMessages.h"
+#include "KeyboardUtil.h"
 
 namespace unity
 {
@@ -804,15 +805,15 @@
 }
 
 Area* DashView::FindKeyFocusArea(unsigned int key_symbol,
-      unsigned long x11_key_code,
-      unsigned long special_keys_state)
+                                 unsigned long x11_key_code,
+                                 unsigned long special_keys_state)
 {
   // Do what nux::View does, but if the event isn't a key navigation,
   // designate the text entry to process it.
 
+  nux::KeyNavDirection direction = KEY_NAV_NONE;
   bool ctrl = (special_keys_state & NUX_STATE_CTRL);
 
-  nux::KeyNavDirection direction = KEY_NAV_NONE;
   switch (x11_key_code)
   {
   case NUX_VK_UP:
@@ -850,7 +851,6 @@
     break;
   default:
     direction = KEY_NAV_NONE;
-    break;
   }
 
   // We should not do it here, but I really don't want to make DashView
@@ -858,7 +858,7 @@
   // DashView::KeyNavIteration.
    nux::InputArea* focus_area = nux::GetWindowCompositor().GetKeyFocusArea();
 
-  if (key_symbol == nux::NUX_KEYDOWN && !search_bar_->im_preedit)
+  if (direction != KEY_NAV_NONE && key_symbol == nux::NUX_KEYDOWN && !search_bar_->im_preedit)
   {
     std::list<nux::Area*> tabs;
     for (auto category : active_lens_view_->categories())
@@ -933,7 +933,18 @@
     }
   }
 
-  if (direction == KEY_NAV_NONE || search_bar_->im_preedit)
+  bool search_key = false;
+
+  if (direction == KEY_NAV_NONE)
+  {
+    if (ui::KeyboardUtil::IsPrintableKeySymbol(x11_key_code) ||
+        ui::KeyboardUtil::IsMoveKeySymbol(x11_key_code))
+    {
+      search_key = true;
+    }
+  }
+
+  if (search_key || search_bar_->im_preedit)
   {
     // then send the event to the search entry
     return search_bar_->text_entry();
@@ -942,7 +953,8 @@
   {
     return next_object_to_key_focus_area_->FindKeyFocusArea(key_symbol, x11_key_code, special_keys_state);
   }
-  return NULL;
+
+  return nullptr;
 }
 
 }

=== modified file 'plugins/unityshell/src/KeyboardUtil.cpp'
--- plugins/unityshell/src/KeyboardUtil.cpp	2011-08-30 12:15:45 +0000
+++ plugins/unityshell/src/KeyboardUtil.cpp	2012-06-28 17:26:31 +0000
@@ -17,9 +17,8 @@
  * Authored by: Jason Smith <[e-mail]>
  */
 
+#include <gdk/gdk.h>
 #include <string.h>
-
-#include <stdio.h>
 #include <cmath>
 
 #include "KeyboardUtil.h"
@@ -31,7 +30,7 @@
   : display_(display)
 {
   unsigned int fetch_mask = XkbGBN_KeyNamesMask | XkbGBN_ClientSymbolsMask | XkbGBN_GeometryMask;
-  keyboard_ = XkbGetKeyboard (display, fetch_mask, XkbUseCoreKbd); 
+  keyboard_ = XkbGetKeyboard (display, fetch_mask, XkbUseCoreKbd);
 }
 
 KeyboardUtil::~KeyboardUtil()
@@ -39,7 +38,7 @@
   XkbFreeKeyboard (keyboard_, 0, True);
 }
 
-bool KeyboardUtil::FindKeyInGeometry(XkbGeometryPtr geo, char *key_name, int& res_section, XkbBoundsRec& res_bounds)
+bool KeyboardUtil::FindKeyInGeometry(XkbGeometryPtr geo, char *key_name, int& res_section, XkbBoundsRec& res_bounds) const
 {
   // seems that Xkb does not give null terminated strings... was painful
   int name_length = XkbKeyNameLength;
@@ -73,7 +72,7 @@
   return false;
 }
 
-bool KeyboardUtil::CompareOffsets (int current_x, int current_y, int best_x, int best_y)
+bool KeyboardUtil::CompareOffsets(int current_x, int current_y, int best_x, int best_y) const
 {
   // never EVER prefer something higher on the keyboard than what we have
   if (current_y > best_y)
@@ -85,7 +84,7 @@
   return false;
 }
 
-guint KeyboardUtil::ConvertKeyToKeycode (XkbKeyPtr key)
+guint KeyboardUtil::ConvertKeyToKeycode(XkbKeyPtr key) const
 {
   int min_code = keyboard_->min_key_code;
   int max_code = keyboard_->max_key_code;
@@ -98,7 +97,7 @@
   return 0;
 }
 
-XkbBoundsRec KeyboardUtil::GetAbsoluteKeyBounds (XkbKeyPtr key, XkbRowPtr row, XkbSectionPtr section, XkbGeometryPtr geo)
+XkbBoundsRec KeyboardUtil::GetAbsoluteKeyBounds(XkbKeyPtr key, XkbRowPtr row, XkbSectionPtr section, XkbGeometryPtr geo) const
 {
   XkbShapePtr shape = XkbKeyShape(geo, key);
 
@@ -117,7 +116,7 @@
       y_offset += local_shape->bounds.y2 - local_shape->bounds.y1;
     else
       x_offset += local_shape->bounds.x2 - local_shape->bounds.x1;
-    
+
     i++;
   }
 
@@ -129,7 +128,7 @@
   return result;
 }
 
-bool KeyboardUtil::FindKeyInSectionAboveBounds (XkbGeometryPtr geo, int section_index, XkbBoundsRec const& target_bounds, guint &keycode)
+bool KeyboardUtil::FindKeyInSectionAboveBounds(XkbGeometryPtr geo, int section_index, XkbBoundsRec const& target_bounds, guint &keycode) const
 {
   XkbKeyPtr best = NULL;
   int best_x_offset = G_MAXINT;
@@ -155,7 +154,7 @@
       int center = (bounds.x1 + bounds.x2) / 2;
       if (center < target_bounds.x1 || center > target_bounds.x2)
         continue;
-      
+
       // make sure the key is actually above our target.
       int current_y_offset = target_bounds.y1 - bounds.y2;
       if (current_y_offset < 0)
@@ -181,7 +180,7 @@
   return false;
 }
 
-guint KeyboardUtil::GetKeycodeAboveKeySymbol(KeySym key_symbol)
+guint KeyboardUtil::GetKeycodeAboveKeySymbol(KeySym key_symbol) const
 {
   guint result = 0;
 
@@ -208,9 +207,38 @@
     if (found_key)
       result = maybe;
   }
-  
+
   return result;
 }
 
+bool KeyboardUtil::IsPrintableKeySymbol(KeySym sym)
+{
+  bool printable_key = false;
+
+  if (sym == XK_Delete || sym == XK_BackSpace || sym == XK_Return)
+  {
+    printable_key = true;
+  }
+  else
+  {
+    unsigned int unicode = gdk_keyval_to_unicode(sym);
+    printable_key = g_unichar_isprint(unicode);
+  }
+
+  return printable_key;
+}
+
+bool KeyboardUtil::IsMoveKeySymbol(KeySym sym)
+{
+  bool move_key = false;
+
+  if (sym >= XK_Home && sym <= XK_Begin)
+  {
+    move_key = true;
+  }
+
+  return move_key;
+}
+
 }
 }
\ No newline at end of file

=== modified file 'plugins/unityshell/src/KeyboardUtil.h'
--- plugins/unityshell/src/KeyboardUtil.h	2012-03-14 06:24:18 +0000
+++ plugins/unityshell/src/KeyboardUtil.h	2012-06-28 17:26:31 +0000
@@ -33,22 +33,23 @@
 
 class KeyboardUtil
 {
-
 public:
-
   KeyboardUtil(Display *display);
-  virtual ~KeyboardUtil();
-
-  guint GetKeycodeAboveKeySymbol(KeySym key_symbol);
+  ~KeyboardUtil();
+
+  guint GetKeycodeAboveKeySymbol(KeySym key_symbol) const;
+
+  static bool IsPrintableKeySymbol(KeySym key_symbol);
+  static bool IsMoveKeySymbol(KeySym sym);
 
 private:
-  bool CompareOffsets (int current_x, int current_y, int best_x, int best_y);
-  guint ConvertKeyToKeycode (XkbKeyPtr key);
-
-  bool FindKeyInGeometry(XkbGeometryPtr geo, char *key_name, int& res_section, XkbBoundsRec& res_bounds);
-  bool FindKeyInSectionAboveBounds (XkbGeometryPtr geo, int section, XkbBoundsRec const& target_bounds, guint &keycode);
-
-  XkbBoundsRec GetAbsoluteKeyBounds (XkbKeyPtr key, XkbRowPtr row, XkbSectionPtr section, XkbGeometryPtr geo);
+  bool CompareOffsets (int current_x, int current_y, int best_x, int best_y) const;
+  guint ConvertKeyToKeycode (XkbKeyPtr key) const;
+
+  bool FindKeyInGeometry(XkbGeometryPtr geo, char *key_name, int& res_section, XkbBoundsRec& res_bounds) const;
+  bool FindKeyInSectionAboveBounds (XkbGeometryPtr geo, int section, XkbBoundsRec const& target_bounds, guint &keycode) const;
+
+  XkbBoundsRec GetAbsoluteKeyBounds (XkbKeyPtr key, XkbRowPtr row, XkbSectionPtr section, XkbGeometryPtr geo) const;
 
   XkbDescPtr keyboard_;
   Display *display_;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-06-19 17:04:29 +0000
+++ tests/CMakeLists.txt	2012-06-28 17:26:31 +0000
@@ -205,6 +205,7 @@
                  test_icon_loader.cpp
                  test_im_text_entry.cpp
                  test_hud_view.cpp
+                 test_keyboard_util.cpp
                  test_resultviewgrid.cpp
                  test_single_monitor_launcher_icon.cpp
                  test_switcher_controller.cpp
@@ -242,6 +243,7 @@
                  ${UNITY_SRC}/LauncherHoverMachine.cpp
                  ${UNITY_SRC}/LauncherIcon.cpp
                  ${UNITY_SRC}/LauncherModel.cpp
+                 ${UNITY_SRC}/KeyboardUtil.cpp
                  ${UNITY_SRC}/OverlayRenderer.cpp
                  ${UNITY_SRC}/JSONParser.cpp
                  ${UNITY_SRC}/SearchBar.cpp

=== added file 'tests/test_keyboard_util.cpp'
--- tests/test_keyboard_util.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_keyboard_util.cpp	2012-06-28 17:26:31 +0000
@@ -0,0 +1,115 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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 (Treviño) <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+#include <algorithm>
+
+#include "KeyboardUtil.h"
+
+using namespace unity::ui;
+
+namespace
+{
+
+void test_key(KeyboardUtil const& key_util, Display* x_display, const char* key)
+{
+  unsigned int above_keycode = key_util.GetKeycodeAboveKeySymbol(XStringToKeysym(key));
+  KeySym above_keysym = XkbKeycodeToKeysym(x_display, above_keycode, 0, 1);
+  EXPECT_NE(above_keysym, NoSymbol);
+}
+
+TEST(TestKeyboardUtil, AboveKeySymbol)
+{
+  Display* x_display = XOpenDisplay(NULL);
+
+  KeyboardUtil key_util(x_display);
+  test_key(key_util, x_display, "Tab");
+  test_key(key_util, x_display, "Shift_R");
+  test_key(key_util, x_display, "Control_L");
+  test_key(key_util, x_display, "space");
+  test_key(key_util, x_display, "comma");
+  test_key(key_util, x_display, "a");
+  test_key(key_util, x_display, "b");
+  test_key(key_util, x_display, "c");
+  test_key(key_util, x_display, "d");
+  test_key(key_util, x_display, "e");
+  test_key(key_util, x_display, "f");
+  test_key(key_util, x_display, "g");
+  test_key(key_util, x_display, "h");
+  test_key(key_util, x_display, "i");
+  test_key(key_util, x_display, "j");
+  test_key(key_util, x_display, "k");
+  test_key(key_util, x_display, "l");
+  test_key(key_util, x_display, "m");
+  test_key(key_util, x_display, "n");
+  test_key(key_util, x_display, "o");
+  test_key(key_util, x_display, "p");
+  test_key(key_util, x_display, "k");
+  test_key(key_util, x_display, "r");
+  test_key(key_util, x_display, "s");
+  test_key(key_util, x_display, "t");
+  test_key(key_util, x_display, "u");
+  test_key(key_util, x_display, "v");
+  test_key(key_util, x_display, "w");
+  test_key(key_util, x_display, "x");
+  test_key(key_util, x_display, "y");
+  test_key(key_util, x_display, "z");
+}
+
+TEST(TestKeyboardUtil, PrintableKeySymbols)
+{
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_Delete));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_BackSpace));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_space));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_3));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_v));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_1));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_ntilde));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_0));
+  EXPECT_TRUE(KeyboardUtil::IsPrintableKeySymbol(XK_exclam));
+
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_F1));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Select));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Hyper_R));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Control_L));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Shift_L));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Super_L));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Print));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Insert));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Num_Lock));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_Caps_Lock));
+  EXPECT_FALSE(KeyboardUtil::IsPrintableKeySymbol(XK_ISO_Level3_Shift));
+}
+
+TEST(TestKeyboardUtil, MoveKeySymbols)
+{
+  std::vector<KeySym> move_symbols { XK_Home, XK_Left, XK_Up, XK_Right, XK_Down,
+                                     XK_Prior, XK_Page_Up, XK_Next, XK_Page_Down,
+                                     XK_End, XK_Begin };
+
+  for (KeySym sym = 0; sym < XK_VoidSymbol; ++sym)
+  {
+    if (std::find(move_symbols.begin(), move_symbols.end(), sym) != move_symbols.end())
+      EXPECT_TRUE(KeyboardUtil::IsMoveKeySymbol(sym));
+    else
+      EXPECT_FALSE(KeyboardUtil::IsMoveKeySymbol(sym));
+  }
+}
+
+} // Namespace