Merge lp:~stolowski/unity-2d/numpad-modifier-support into lp:unity-2d

[Paweł Stołowski]

[launcher] Added support for Super + keypad 0..9 hotkeys.
Implemented by adding special handling for Qt::KeypadModifier in Hotkey ctor.

[launcher] Added support for Super + keypad 0..9 hotkeys.
Implemented by adding special handling for Qt::KeypadModifier in Hotkey ctor.

[Gerry Boland (gerboland)]

Works great, thank you Pawel!

review: Approve

=== modified file 'libunity-2d-private/src/hotkey.cpp'
--- libunity-2d-private/src/hotkey.cpp	2012-02-03 13:36:16 +0000
+++ libunity-2d-private/src/hotkey.cpp	2012-03-16 17:21:19 +0000
@@ -28,6 +28,10 @@
 #include <X11/extensions/XKB.h>
 #include <X11/Xproto.h>
 
+// XK_MISCELLANY is needed for XK_KP_* keysymdef definitions
+#define XK_MISCELLANY
+#include <X11/keysymdef.h>
+
 #include <debug_p.h>
 
 static int (*_x_old_errhandler)(Display *, XErrorEvent *);
@@ -64,24 +68,37 @@
     if (modifiers.testFlag(Qt::MetaModifier)) {
         m_x11modifiers |= Mod4Mask;
     }
-
-    /* Translate the QT key to X11 keycode */
-
-    /* QKeySequence can be used to translate a Qt::Key in a format that is
-       understood by XStringToKeysym if the sequence is composed only by the key */
-    QString keyString = QKeySequence(key).toString();
-    KeySym keysym = XStringToKeysym(keyString.toLatin1().data());
-    if (keysym == NoSymbol) {
-        /* XStringToKeysym doesn’t work well with exotic characters (such as
-          'É'). Note that this fallback code path looks much simpler but doesn’t
-          work for special keys such as the function keys (e.g. F1), which is
-          why the translation with XStringToKeysym is attempted first. */
-        keysym = (ushort) key;
-    }
-    m_x11key = XKeysymToKeycode(QX11Info::display(), keysym);
-    if (m_x11key == 0) {
-        UQ_WARNING << "Could not get keycode for keysym" << keysym
-                   << "(" << keyString << ")";
+    if (modifiers.testFlag(Qt::KeypadModifier)) {
+        /* Support 0..9 numpad keys only.
+           If we ever need to support additional numpad keys, then this logic should be extended
+           in the spirit of Qt's qkeymapper_x11.cpp.  */
+        if (key >= Qt::Key_0 && key <= Qt::Key_9) {
+            /* Please note that we don't set Mod2Mask (NumLock) modifier. It appears that Mod2 is reported
+               when it's actually held during numkey key press.
+            */
+            m_x11key = XKeysymToKeycode(QX11Info::display(), XK_KP_9 - (Qt::Key_9 - key));
+        } else {
+            UQ_WARNING << "Can't map numpad keys other than 0..9";
+        }
+    } else {
+        /* Translate the QT key to X11 keycode */
+
+        /* QKeySequence can be used to translate a Qt::Key in a format that is
+           understood by XStringToKeysym if the sequence is composed only by the key */
+        QString keyString = QKeySequence(key).toString();
+        KeySym keysym = XStringToKeysym(keyString.toLatin1().data());
+        if (keysym == NoSymbol) {
+            /* XStringToKeysym doesn’t work well with exotic characters (such as
+              'É'). Note that this fallback code path looks much simpler but doesn’t
+              work for special keys such as the function keys (e.g. F1), which is
+              why the translation with XStringToKeysym is attempted first. */
+            keysym = (ushort) key;
+        }
+        m_x11key = XKeysymToKeycode(QX11Info::display(), keysym);
+        if (m_x11key == 0) {
+            UQ_WARNING << "Could not get keycode for keysym" << keysym
+                       << "(" << keyString << ")";
+        }
     }
 }
 

=== modified file 'libunity-2d-private/tests/CMakeLists.txt'
--- libunity-2d-private/tests/CMakeLists.txt	2012-03-13 18:54:14 +0000
+++ libunity-2d-private/tests/CMakeLists.txt	2012-03-16 17:21:19 +0000
@@ -39,9 +39,12 @@
     qsortfilterproxymodeltest
     focuspathtest
     pointerbarriertest
+    hotkeytest
     )
 
 target_link_libraries(pointerbarriertest ${X11_XTest_LIB})
+
+target_link_libraries(hotkeytest ${X11_XTest_LIB})
     
 # unity2dtrtest - FIXME
 #add_test(NAME unity2dtrtest_check

=== added file 'libunity-2d-private/tests/hotkeytest.cpp'
--- libunity-2d-private/tests/hotkeytest.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/tests/hotkeytest.cpp	2012-03-16 17:21:19 +0000
@@ -0,0 +1,218 @@
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2012 Canonical Ltd.
+ *
+ * Authors:
+ * - Pawel Stolowski <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ */
+
+#include <unitytestmacro.h>
+#include <hotkey.h>
+#include <hotkeymonitor.h>
+
+#include <QApplication>
+#include <QX11Info>
+#include <QtTestGui>
+
+// XK_MISCELLANY and XK_LATIN1 are needed for XK_* keysymdef definitions
+#define XK_MISCELLANY
+#define XK_LATIN1
+#include <X11/keysymdef.h>
+#include <X11/extensions/XTest.h>
+
+/* Helper class that connects to Hotkey pressed() signal and
+   records key/modifiers and total number of key presses */
+class HotKeyPressReceiver: public QObject
+{
+    Q_OBJECT
+public:
+    HotKeyPressReceiver(): m_count(0) {
+    }
+
+    int count() const { return m_count; }
+    void reset() { m_count = 0; }
+    Qt::Key key() const { return m_key; }
+    Qt::KeyboardModifiers modifiers() const { return m_modifiers; }
+
+public Q_SLOTS:
+    void onKeyPressed() {
+        Hotkey* hotkey = qobject_cast<Hotkey*>(sender());
+
+        m_key = hotkey->key();
+        m_modifiers = hotkey->modifiers();
+       ++m_count;
+    }
+
+ private:
+    Qt::Key m_key;
+    Qt::KeyboardModifiers m_modifiers;
+    int m_count;
+};
+
+class HotkeyTest: public QObject
+{
+    static void simulateKey(KeySym keysym, KeySym modsym1, KeySym modsym2 = 0)  {
+        Display *disp = QX11Info::display();
+
+        KeyCode modcode1, modcode2;
+        KeyCode keycode = XKeysymToKeycode(disp, keysym);
+
+        XTestGrabControl (disp, True);  
+
+        /* Generate modkey press */  
+        if (modsym1 != 0)  { 
+            modcode1 = XKeysymToKeycode(disp, modsym1);
+            XTestFakeKeyEvent(disp, modcode1, True, 0);
+        }
+      
+        if (modsym2 != 0)  { 
+            modcode2 = XKeysymToKeycode(disp, modsym2);
+            XTestFakeKeyEvent(disp, modcode2, True, 1);
+        }
+
+        /* Generate regular key press and release */  
+        XTestFakeKeyEvent(disp, keycode, True, 10); 
+        XTestFakeKeyEvent(disp, keycode, False, 20);
+      
+        /* Generate modkey release */  
+        if (modsym1 != 0) { 
+            XTestFakeKeyEvent(disp, modcode1, False, 40);
+        }
+
+        if (modsym2 != 0) { 
+            XTestFakeKeyEvent(disp, modcode2, False, 41);
+        }
+      
+        XSync(disp, False); 
+        XTestGrabControl(disp, False); 
+        
+        /* Process Qt events. This is crucial since simulated keypress won't automagically trigger Qt signal */
+        QApplication::processEvents();
+    } 
+
+    Q_OBJECT
+private Q_SLOTS:
+
+    void initTestCase()
+    {
+       for (Qt::Key key = Qt::Key_0; key <= Qt::Key_9; key = (Qt::Key) (key + 1)) {
+            Hotkey* hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier);
+            connect(hotkey, SIGNAL(pressed()), &m_rcv, SLOT(onKeyPressed()));
+            hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier | Qt::ShiftModifier);
+            connect(hotkey, SIGNAL(pressed()), &m_shiftrcv, SLOT(onKeyPressed()));
+            hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier | Qt::KeypadModifier);
+            connect(hotkey, SIGNAL(pressed()), &m_keypadrcv, SLOT(onKeyPressed()));
+        }
+    }
+
+    void init()
+    {
+        m_rcv.reset();
+        m_shiftrcv.reset();
+        m_keypadrcv.reset();
+    }
+
+    /* Test super + number hotkeys */
+    void testNumericKeypress()
+    {
+        QCOMPARE(m_rcv.count(), 0);
+
+        simulateKey(XK_1, XK_Super_L);
+        QCOMPARE(m_rcv.count(), 1);
+        QCOMPARE(m_keypadrcv.count(), 0);
+        QCOMPARE(m_shiftrcv.count(), 0);
+        QCOMPARE(m_rcv.key(), Qt::Key_1);
+        QCOMPARE(m_rcv.modifiers(), Qt::MetaModifier);
+        
+        simulateKey(XK_9, XK_Super_L);
+        QCOMPARE(m_rcv.count(), 2);
+        QCOMPARE(m_keypadrcv.count(), 0);
+        QCOMPARE(m_shiftrcv.count(), 0);
+        QCOMPARE(m_rcv.key(), Qt::Key_9);
+        QCOMPARE(m_rcv.modifiers(), Qt::MetaModifier);
+
+        simulateKey(XK_0, XK_Super_L);
+        QCOMPARE(m_rcv.count(), 3);
+        QCOMPARE(m_keypadrcv.count(), 0);
+        QCOMPARE(m_shiftrcv.count(), 0);
+        QCOMPARE(m_rcv.key(), Qt::Key_0);
+        QCOMPARE(m_rcv.modifiers(), Qt::MetaModifier);
+    }
+    
+    /* Test for super + shift + number hotkeys */
+    void testShiftNumericKeypress()
+    {
+        QCOMPARE(m_shiftrcv.count(), 0);
+       
+        simulateKey(XK_1, XK_Super_L, XK_Shift_L);
+        QCOMPARE(m_shiftrcv.count(), 1);
+        QCOMPARE(m_rcv.count(), 0);
+        QCOMPARE(m_keypadrcv.count(), 0);
+        QCOMPARE(m_shiftrcv.key(), Qt::Key_1);
+        QCOMPARE(m_shiftrcv.modifiers(), Qt::MetaModifier | Qt::ShiftModifier);
+        
+        simulateKey(XK_9, XK_Super_L, XK_Shift_L);
+        QCOMPARE(m_shiftrcv.count(), 2);
+        QCOMPARE(m_rcv.count(), 0);
+        QCOMPARE(m_keypadrcv.count(), 0);
+        QCOMPARE(m_shiftrcv.key(), Qt::Key_9);
+        QCOMPARE(m_shiftrcv.modifiers(), Qt::MetaModifier | Qt::ShiftModifier);
+
+        simulateKey(XK_0, XK_Super_L, XK_Shift_L);
+        QCOMPARE(m_shiftrcv.count(), 3);
+        QCOMPARE(m_rcv.count(), 0);
+        QCOMPARE(m_keypadrcv.count(), 0);
+        QCOMPARE(m_shiftrcv.key(), Qt::Key_0);
+        QCOMPARE(m_shiftrcv.modifiers(), Qt::MetaModifier | Qt::ShiftModifier);
+    }
+   
+    /* Test for super + numeric keyboard hotkeys */
+    void testNumpadNumericKeypress()
+    {
+        QCOMPARE(m_keypadrcv.count(), 0);
+       
+        simulateKey(XK_KP_1, XK_Super_L);
+        QCOMPARE(m_keypadrcv.count(), 1);
+        QCOMPARE(m_rcv.count(), 0);
+        QCOMPARE(m_shiftrcv.count(), 0);
+        QCOMPARE(m_keypadrcv.key(), Qt::Key_1);
+        QCOMPARE(m_keypadrcv.modifiers(), Qt::MetaModifier | Qt::KeypadModifier);
+        
+        simulateKey(XK_KP_9, XK_Super_L);
+        QCOMPARE(m_keypadrcv.count(), 2);
+        QCOMPARE(m_rcv.count(), 0);
+        QCOMPARE(m_shiftrcv.count(), 0);
+        QCOMPARE(m_keypadrcv.key(), Qt::Key_9);
+        QCOMPARE(m_keypadrcv.modifiers(), Qt::MetaModifier | Qt::KeypadModifier);
+
+        simulateKey(XK_KP_0, XK_Super_L);
+        QCOMPARE(m_keypadrcv.count(), 3);
+        QCOMPARE(m_rcv.count(), 0);
+        QCOMPARE(m_shiftrcv.count(), 0);
+        QCOMPARE(m_keypadrcv.key(), Qt::Key_0);
+        QCOMPARE(m_keypadrcv.modifiers(), Qt::MetaModifier | Qt::KeypadModifier);
+    }
+        
+private:
+    HotKeyPressReceiver m_rcv; // monitor for meta+number hotkeys
+    HotKeyPressReceiver m_shiftrcv; //monitor for meta+shift+number hotkeys
+    HotKeyPressReceiver m_keypadrcv; //monitor for meta+numpad hotkeys
+};
+ 
+UAPP_TEST_MAIN(HotkeyTest)
+
+#include "hotkeytest.moc"
+

=== modified file 'shell/app/shellmanager.cpp'
--- shell/app/shellmanager.cpp	2012-03-14 08:52:49 +0000
+++ shell/app/shellmanager.cpp	2012-03-16 17:21:19 +0000
@@ -306,6 +306,8 @@
         connect(hotkey, SIGNAL(pressed()), SLOT(onNumericHotkeyPressed()));
         hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier | Qt::ShiftModifier);
         connect(hotkey, SIGNAL(pressed()), SLOT(onNumericHotkeyPressed()));
+        hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier | Qt::KeypadModifier);
+        connect(hotkey, SIGNAL(pressed()), SLOT(onNumericHotkeyPressed()));
     }
 
     // FIXME: we need to use a queued connection here otherwise QConf will deadlock for some reason