Merge lp:~uriboni/unity-2d/launcher-keyboard-shortcuts into lp:unity-2d/3.0

[Ugo Riboni]

[launcher] Make the first 10 items in the launcher able to be activated via Super+n, and show the launcher when Super is pressed if hidden.

Make the first 10 items in the launcher able to be activated via Super+n, and show the launcher when Super is pressed if hidden.

Please note that this branch has already merged into it the following branches:
lp:~fboucault/unity-2d/more_robust_intellihide and
lp:~fboucault/unity-2d/launcher_four_fingers_drag

[Florian Boucault (fboucault)]

Attempt to merge into lp:unity-2d failed due to conflicts:

text conflict in launcher/LauncherItem.qml
text conflict in launcher/app/CMakeLists.txt
text conflict in libunity-2d-private/src/CMakeLists.txt
text conflict in places/app/places.cpp

=== modified file 'launcher/LauncherItem.qml'
--- launcher/LauncherItem.qml	2011-02-18 14:02:46 +0000
+++ launcher/LauncherItem.qml	2011-02-24 00:23:17 +0000
@@ -53,6 +53,9 @@
     property bool backgroundFromIcon
     property color defaultBackgroundColor: "#333333"
 
+    property alias shortcutVisible: shortcut.visible
+    property alias shortcutText: shortcutText.text
+
     property int pips: 0
     property string pipSource: engineBaseUrl + "artwork/launcher_" +
                                ((pips <= 1) ? "arrow" : "pip") + "_ltr.png"
@@ -263,6 +266,21 @@
             }
         }
 
+        Rectangle {
+            id: shortcut
+            anchors.centerIn: parent
+            color: "#B3000000" // 0.7 opacity on black
+            radius: 2
+            width: 22
+            height: 22
+
+            Text {
+                id: shortcutText
+                anchors.centerIn: parent
+                color: "white"
+            }
+        }
+
         Image {
             id: emblemIcon
             anchors.left: parent.left
 
=== modified file 'launcher/LauncherList.qml'
--- launcher/LauncherList.qml	2011-02-21 10:23:45 +0000
+++ launcher/LauncherList.qml	2011-02-24 00:23:17 +0000
@@ -31,6 +31,10 @@
         emblem: (noOverlays && item.emblem) ? "image://icons/" + item.emblem : ""
         emblemVisible: (noOverlays) ? false : item.emblemVisible
 
+        shortcutVisible: item.toString().indexOf("LauncherApplication") == 0 &&
+                         index <= 9 && launcherView.superKeyPressed
+        shortcutText: index + 1
+
         /* Best way I could find to check if the item is an application or the
            workspaces switcher. There may be something cleaner and better. */
         backgroundFromIcon: item.toString().indexOf("LauncherApplication") == 0 ||
@@ -121,5 +125,16 @@
             /* Not all items are applications. */
             ignoreUnknownSignals: true
         }
+
+        Connections {
+            target: launcherView
+            onKeyboardShortcutPressed: {
+                /* Only applications can be launched by keyboard shortcuts */
+                if (item.toString().indexOf("LauncherApplication") == 0 && index == itemIndex) {
+                    item.menu.hide()
+                    item.activate()
+                }
+            }
+        }
     }
 }
 
=== modified file 'launcher/app/CMakeLists.txt'
--- launcher/app/CMakeLists.txt	2011-02-16 02:21:24 +0000
+++ launcher/app/CMakeLists.txt	2011-02-24 00:23:17 +0000
@@ -2,6 +2,7 @@
 pkg_check_modules(GTK REQUIRED gtk+-2.0)
 pkg_check_modules(X11 REQUIRED x11)
 pkg_check_modules(GEIS REQUIRED libutouch-geis)
+pkg_check_modules(QTGCONF REQUIRED libqtgconf)
 
 # Sources
 set(launcher_SRCS
@@ -34,6 +35,7 @@
     ${GTK_INCLUDE_DIRS}
     ${X11_INCLUDE_DIRS}
     ${GEIS_INCLUDE_DIRS}
+    ${QTGCONF_INCLUDE_DIRS}
     ${libunity-2d-private_SOURCE_DIR}/src
     )
 
@@ -45,6 +47,7 @@
     ${GTK_LDFLAGS}
     ${X11_LDFLAGS}
     ${GEIS_LDFLAGS}
+    ${QTGCONF_LDFLAGS}
     unity-2d-private
     )
 
 
=== modified file 'launcher/app/launcher.cpp'
--- launcher/app/launcher.cpp	2011-02-22 16:54:40 +0000
+++ launcher/app/launcher.cpp	2011-02-24 00:23:17 +0000
@@ -29,6 +29,8 @@
 #include <QDeclarativeContext>
 #include <QDir>
 
+#include <unity2dapplication.h>
+
 #include "config.h"
 #include "launcherview.h"
 #include "launchercontrol.h"
@@ -53,7 +55,7 @@
     */
     QApplication::setGraphicsSystem("raster");
     QApplication::setColorSpec(QApplication::ManyColor);
-    QApplication application(argc, argv);
+    Unity2dApplication application(argc, argv);
 
     GnomeSessionClient client(INSTALL_PREFIX "/share/applications/unity-2d-launcher.desktop");
     client.connectToSessionManager();
 
=== modified file 'launcher/app/launcherview.cpp'
--- launcher/app/launcherview.cpp	2011-02-16 11:11:46 +0000
+++ launcher/app/launcherview.cpp	2011-02-24 00:23:17 +0000
@@ -35,13 +35,95 @@
 #include <X11/Xatom.h>
 
 #include "dragdropevent.h"
+#include <keyboardmodifiersmonitor.h>
+#include <hotkey.h>
+#include <hotkeymonitor.h>
 
 LauncherView::LauncherView() :
     QDeclarativeView(), m_resizing(false), m_reserved(false),
     m_dndCurrentLauncherItem(NULL), m_dndCurrentLauncherItemAccepted(false),
-    m_dndAccepted(false)
+    m_dndAccepted(false), m_superKeyPressed(false)
 {
     setAcceptDrops(true);
+
+    m_enableSuperKey.setKey("/desktop/unity/launcher/super_key_enable");
+    QObject::connect(&m_enableSuperKey, SIGNAL(valueChanged()),
+                     this, SLOT(updateSuperKeyMonitoring()));
+    updateSuperKeyMonitoring();
+}
+
+void
+LauncherView::updateSuperKeyMonitoring()
+{
+    KeyboardModifiersMonitor *modifiersMonitor = KeyboardModifiersMonitor::instance();
+
+    QVariant value = m_enableSuperKey.getValue();
+    if (!value.isValid() || value.toBool() == true) {
+        QObject::connect(modifiersMonitor,
+                         SIGNAL(keyboardModifiersChanged(Qt::KeyboardModifiers)),
+                         this, SLOT(setHotkeysForModifiers(Qt::KeyboardModifiers)));
+        setHotkeysForModifiers(modifiersMonitor->keyboardModifiers());
+    } else {
+        QObject::disconnect(modifiersMonitor,
+                            SIGNAL(keyboardModifiersChanged(Qt::KeyboardModifiers)),
+                            this, SLOT(setHotkeysForModifiers(Qt::KeyboardModifiers)));
+        m_superKeyPressed = false;
+        Q_EMIT superKeyPressedChanged(false);
+        changeKeyboardShortcutsState(false);
+    }
+}
+
+void
+LauncherView::setHotkeysForModifiers(Qt::KeyboardModifiers modifiers)
+{
+    /* This is the new new state of the Super key (AKA Meta key), while
+       m_superKeyPressed is the previous state of the key at the last modifiers change. */
+    bool superKeyPressed = modifiers.testFlag(Qt::MetaModifier);
+
+    if (m_superKeyPressed != superKeyPressed) {
+        m_superKeyPressed = superKeyPressed;
+        Q_EMIT superKeyPressedChanged(m_superKeyPressed);
+        changeKeyboardShortcutsState(m_superKeyPressed);
+    }
+}
+
+void
+LauncherView::changeKeyboardShortcutsState(bool enabled)
+{
+    /* We are going to connect 10 Hotkeys, but to make things simpler on the QML
+       side we want to have only one signal with the number of the item that needs to
+       be activated in response to the hotkey press.
+       So we connect all of them to a single slot where we emit a single signal with
+       an index based on which Hotkey was the sender. */
+    Qt::Key key = Qt::Key_0;
+    while (key <= Qt::Key_9) {
+        Hotkey *hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier);
+
+        if (enabled) {
+            QObject::connect(hotkey, SIGNAL(pressed()), this, SLOT(forwardHotkey()));
+        } else {
+            QObject::disconnect(hotkey, SIGNAL(pressed()), this, SLOT(forwardHotkey()));
+        }
+        key = (Qt::Key) (key + 1);
+    }
+}
+
+void
+LauncherView::forwardHotkey()
+{
+    Hotkey *hotkey = qobject_cast<Hotkey*>(sender());
+    if (hotkey != NULL) {
+        /* Shortcuts from 1 to 9 should activate the items with index
+           from 0 to 8. Shortcut for 0 should activate item with index 10.
+           In other words, the indexes are activated in the same order as
+           the keys appear on a standard keyboard. */
+        int itemIndex = hotkey->key() - Qt::Key_0;
+        itemIndex = (itemIndex == 0) ? 9 : itemIndex - 1;
+
+        if (itemIndex >= 0 && itemIndex <= 10) {
+            Q_EMIT keyboardShortcutPressed(itemIndex);
+        }
+    }
 }
 
 QGraphicsObject*
 
=== modified file 'launcher/app/launcherview.h'
--- launcher/app/launcherview.h	2011-02-16 11:11:46 +0000
+++ launcher/app/launcherview.h	2011-02-24 00:23:17 +0000
@@ -24,23 +24,36 @@
 #include <QUrl>
 #include <QList>
 #include <QDragEnterEvent>
+#include "gconfitem-qml-wrapper.h"
 
 class QGraphicsObject;
 
 class LauncherView : public QDeclarativeView
 {
     Q_OBJECT
+    Q_PROPERTY(bool superKeyPressed READ superKeyPressed
+                                    NOTIFY superKeyPressedChanged)
 
 public:
     explicit LauncherView();
     Q_INVOKABLE QList<QVariant> getColorsFromIcon(QUrl source, QSize size) const;
 
-signals:
+    bool superKeyPressed() const { return m_superKeyPressed; }
+
+Q_SIGNALS:
     void desktopFileDropped(QString path);
     void webpageUrlDropped(const QUrl& url);
+    void keyboardShortcutPressed(int itemIndex);
+    void superKeyPressedChanged(bool superKeyPressed);
+
+private Q_SLOTS:
+    void setHotkeysForModifiers(Qt::KeyboardModifiers modifiers);
+    void forwardHotkey();
+    void updateSuperKeyMonitoring();
 
 private:
     QList<QUrl> getEventUrls(QDropEvent*);
+    void changeKeyboardShortcutsState(bool enabled);
 
     /* Whether the launcher is already being resized */
     bool m_resizing;
@@ -63,6 +76,9 @@
     bool m_dndCurrentLauncherItemAccepted;
     /* Whether the launcher itself handles the current dnd event */
     bool m_dndAccepted;
+
+    GConfItemQmlWrapper m_enableSuperKey;
+    bool m_superKeyPressed;
 };
 
 #endif // LAUNCHERVIEW
 
=== modified file 'launcher/tests/CMakeLists.txt'
--- launcher/tests/CMakeLists.txt	2011-01-27 16:23:33 +0000
+++ launcher/tests/CMakeLists.txt	2011-02-24 00:23:17 +0000
@@ -22,6 +22,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/../UnityApplications
     ${CMAKE_CURRENT_BINARY_DIR}
     ${QT_QTTEST_INCLUDE_DIR}
+    ${QTGCONF_INCLUDE_DIRS}
     )
 
 enable_testing()
 
=== modified file 'libunity-2d-private/src/CMakeLists.txt'
--- libunity-2d-private/src/CMakeLists.txt	2011-02-11 11:37:55 +0000
+++ libunity-2d-private/src/CMakeLists.txt	2011-02-24 00:23:17 +0000
@@ -2,6 +2,8 @@
 set(libunity-2d-private_SRCS
     gnomesessionclient.cpp
     keyboardmodifiersmonitor.cpp
+    hotkeymonitor.cpp
+    hotkey.cpp
     unity2dapplication.cpp
     unity2dpanel.cpp
     mimedata.cpp
 
=== added file 'libunity-2d-private/src/hotkey.cpp'
--- libunity-2d-private/src/hotkey.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/hotkey.cpp	2011-02-24 00:23:17 +0000
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Ugo Riboni <[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 "hotkey.h"
+
+#include <QX11Info>
+#include <QDebug>
+#include <QKeySequence>
+
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKB.h>
+
+Hotkey::Hotkey(Qt::Key key, Qt::KeyboardModifiers modifiers, QObject *parent) :
+    QObject(parent), m_connections(0),
+    m_key(key), m_modifiers(modifiers),
+    m_x11key(0), m_x11modifiers(0)
+{
+    /* Translate the QT modifiers to X11 modifiers */
+
+    if (modifiers.testFlag(Qt::ShiftModifier)) {
+        m_x11modifiers |= ShiftMask ;
+    }
+    if (modifiers.testFlag(Qt::ControlModifier)) {
+        m_x11modifiers |= ControlMask ;
+    }
+    if (modifiers.testFlag(Qt::AltModifier)) {
+        m_x11modifiers |= Mod1Mask;
+    }
+    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) {
+        qWarning() << "Could not convert" << keyString << "to an x11 keysym";
+    } else {
+        m_x11key = XKeysymToKeycode(QX11Info::display(), keysym);
+        if (m_x11key == 0) {
+            qWarning() << "Could not get keycode for keysym" << keysym
+                       << "(" << keyString << ")";
+        }
+    }
+}
+
+void
+Hotkey::connectNotify(const char * signal)
+{
+    Q_UNUSED(signal);
+    if (m_connections == 0) {
+        qDebug() << "Grabbing hotkey" << QKeySequence(m_key | m_modifiers).toString();
+        XGrabKey(QX11Info::display(), m_x11key, m_x11modifiers,
+                 QX11Info::appRootWindow(), True, GrabModeAsync, GrabModeAsync);
+    }
+    m_connections++;
+}
+
+void
+Hotkey::disconnectNotify(const char * signal)
+{
+    Q_UNUSED(signal);
+    if (m_connections == 1) {
+        qDebug() << "Ungrabbing hotkey" << QKeySequence(m_key | m_modifiers).toString();
+        XUngrabKey(QX11Info::display(), m_x11key, m_x11modifiers,
+                   QX11Info::appRootWindow());
+    }
+    m_connections--;
+}
+
+bool
+Hotkey::processNativeEvent(uint x11Keycode, uint x11Modifiers, bool isPressEvent)
+{
+    if (x11Keycode == m_x11key && x11Modifiers == m_x11modifiers) {
+        Q_EMIT (isPressEvent) ? pressed() : released();
+        return true;
+    }
+    return false;
+}
+
+#include "hotkey.moc"
 
=== added file 'libunity-2d-private/src/hotkey.h'
--- libunity-2d-private/src/hotkey.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/hotkey.h	2011-02-24 00:23:17 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Ugo Riboni <[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/>.
+ */
+
+#ifndef Hotkey_H
+#define Hotkey_H
+
+#include <QObject>
+
+class Hotkey : public QObject
+{
+    friend class HotkeyMonitor;
+
+    Q_OBJECT
+    Q_PROPERTY(Qt::Key key READ key NOTIFY keyChanged)
+    Q_PROPERTY(Qt::KeyboardModifiers modifiers READ modifiers NOTIFY modifiersChanged)
+
+public:
+    Qt::Key key() const { return m_key; }
+    Qt::KeyboardModifiers modifiers() const { return m_modifiers; }
+
+Q_SIGNALS:
+    void keyChanged(Qt::Key key);
+    void modifiersChanged(Qt::KeyboardModifiers modifiers);
+    void pressed();
+    void released();
+
+protected:
+    virtual void connectNotify(const char * signal);
+    virtual void disconnectNotify(const char * signal);
+
+private:
+    Hotkey(Qt::Key key, Qt::KeyboardModifiers modifiers, QObject *parent);
+    bool processNativeEvent(uint x11Keycode, uint x11Modifiers, bool isPressEvent);
+
+private:
+    uint m_connections;
+    Qt::Key m_key;
+    Qt::KeyboardModifiers m_modifiers;
+    uint m_x11key;
+    uint m_x11modifiers;
+};
+
+#endif // Hotkey_H
 
=== added file 'libunity-2d-private/src/hotkeymonitor.cpp'
--- libunity-2d-private/src/hotkeymonitor.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/hotkeymonitor.cpp	2011-02-24 00:23:17 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Ugo Riboni <[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 "hotkeymonitor.h"
+#include "hotkey.h"
+
+#include <QDebug>
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKB.h>
+
+#include <QX11Info>
+#include <QAbstractEventDispatcher>
+
+HotkeyMonitor::HotkeyMonitor(QObject* parent)
+    : QObject(parent)
+{
+    int opcode, baseError, baseEvent;
+    if (XkbQueryExtension(QX11Info::display(), &opcode, &baseEvent,
+                          &baseError, NULL, NULL) == False) {
+        qWarning() << "Failed to initialize Xkb extension. CapsLock and NumLock"
+                      "active will prevent shortcuts from working.";
+    } else {
+        /* With this call we ignore CapsLock and NumLock when grabbing keys. */
+        XkbSetIgnoreLockMods(QX11Info::display(), XkbUseCoreKbd,
+                             Mod2Mask | LockMask, Mod2Mask | LockMask,
+                             0, 0);
+    }
+
+    QAbstractEventDispatcher::instance()->setEventFilter(HotkeyMonitor::keyEventFilter);
+}
+
+HotkeyMonitor&
+HotkeyMonitor::instance()
+{
+    static HotkeyMonitor monitor;
+    return monitor;
+}
+
+HotkeyMonitor::~HotkeyMonitor()
+{
+    qDeleteAll(m_hotkeys);
+}
+
+
+Hotkey*
+HotkeyMonitor::getHotkeyFor(Qt::Key key, Qt::KeyboardModifiers modifiers)
+{
+    Q_FOREACH(Hotkey* currentHotkey, m_hotkeys) {
+        if (currentHotkey->key() == key &&
+            currentHotkey->modifiers() == modifiers) {
+            return currentHotkey;
+        }
+    }
+
+    Hotkey *hotkey = new Hotkey(key, modifiers, this);
+    m_hotkeys.append(hotkey);
+    return hotkey;
+}
+
+bool
+HotkeyMonitor::keyEventFilter(void* message)
+{
+    XEvent* event = static_cast<XEvent*>(message);
+    if (event->type == KeyRelease || event->type == KeyPress)
+    {
+        XKeyEvent* key = (XKeyEvent*) event;
+        HotkeyMonitor::instance().processKeyEvent(key->keycode, key->state,
+                                                  event->type == KeyPress);
+    }
+    return false;
+}
+
+void
+HotkeyMonitor::processKeyEvent(uint x11Keycode, uint x11Modifiers,
+                               bool isPressEvent)
+{
+    Q_FOREACH(Hotkey* hotkey, m_hotkeys) {
+        if (hotkey->processNativeEvent(x11Keycode, x11Modifiers, isPressEvent)) {
+            return;
+        }
+    }
+    qWarning() << "Received x11 key event that wasn't processed by any hotkey:"
+               << x11Keycode << x11Modifiers << ((isPressEvent) ? "Press" : "Release");
+}
+
+#include "hotkeymonitor.moc"
 
=== added file 'libunity-2d-private/src/hotkeymonitor.h'
--- libunity-2d-private/src/hotkeymonitor.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/hotkeymonitor.h	2011-02-24 00:23:17 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Ugo Riboni <[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/>.
+ */
+
+#ifndef HotkeyMonitor_H
+#define HotkeyMonitor_H
+
+#include <QObject>
+#include <QList>
+
+class Hotkey;
+
+class HotkeyMonitor : public QObject
+{
+    Q_OBJECT
+
+public:
+    static HotkeyMonitor& instance();
+    ~HotkeyMonitor();
+
+    Hotkey* getHotkeyFor(Qt::Key key, Qt::KeyboardModifiers modifiers);
+
+private:
+    HotkeyMonitor(QObject* parent=0);
+
+    static bool keyEventFilter(void* message);
+    void processKeyEvent(uint x11Keycode, uint x11Modifiers,
+                         bool isPressEvent);
+
+    QList<Hotkey*> m_hotkeys;
+};
+
+
+#endif // HotkeyMonitor_H
+
 
=== modified file 'places/app/CMakeLists.txt'
--- places/app/CMakeLists.txt	2011-01-10 18:25:49 +0000
+++ places/app/CMakeLists.txt	2011-02-24 00:23:17 +0000
@@ -4,15 +4,11 @@
 
 # Sources
 set(places_SRCS
-    keymonitor.cpp
-    superkeymonitor.cpp
     places.cpp
     dashdeclarativeview.cpp
     )
 
 set(places_MOC_HDRS
-    keymonitor.h
-    superkeymonitor.h
     dashdeclarativeview.h
     )
 
 
=== removed file 'places/app/keymonitor.cpp'
--- places/app/keymonitor.cpp	2011-01-12 09:17:58 +0000
+++ places/app/keymonitor.cpp	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2011 Canonical, Ltd.
- *
- * Authors:
- *  Olivier Tilloy <[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 "keymonitor.h"
-
-#include <X11/Xlib.h>
-
-#include <QX11Info>
-
-KeyMonitor::KeyMonitor(int keycode, QObject* parent)
-    : QObject(parent)
-    , m_keycode(keycode)
-    , m_grabbed(false)
-{
-}
-
-KeyMonitor::~KeyMonitor()
-{
-    if (m_grabbed) {
-        ungrabKey();
-    }
-}
-
-void
-KeyMonitor::grabKey()
-{
-    Display* display = QX11Info::display();
-    Window window = QX11Info::appRootWindow();
-    Bool owner = True;
-    int pointer = GrabModeAsync;
-    int keyboard = GrabModeAsync;
-    XGrabKey(display, m_keycode, 0, window, owner, pointer, keyboard);
-    /* Assume no X error. */
-    m_grabbed = true;
-}
-
-void
-KeyMonitor::ungrabKey()
-{
-    Display* display = QX11Info::display();
-    Window window = QX11Info::appRootWindow();
-    XUngrabKey(display, m_keycode, 0, window);
-    /* Assume no X error. */
-    m_grabbed = false;
-}
-
 
=== removed file 'places/app/keymonitor.h'
--- places/app/keymonitor.h	2011-01-11 12:37:45 +0000
+++ places/app/keymonitor.h	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2011 Canonical, Ltd.
- *
- * Authors:
- *  Olivier Tilloy <[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/>.
- */
-
-#ifndef KeyMonitor_H
-#define KeyMonitor_H
-
-#include <QObject>
-
-class KeyMonitor : public QObject
-{
-    Q_OBJECT
-
-public:
-    KeyMonitor(int keycode, QObject* parent=0);
-    ~KeyMonitor();
-
-    void grabKey();
-    void ungrabKey();
-
-private:
-    int m_keycode;
-    bool m_grabbed;
-};
-
-#endif // KeyMonitor_H
-
 
=== modified file 'places/app/places.cpp'
--- places/app/places.cpp	2011-02-02 16:57:00 +0000
+++ places/app/places.cpp	2011-02-24 00:23:17 +0000
@@ -30,8 +30,6 @@
 #include <X11/Xlib.h>
 
 #include "dashdeclarativeview.h"
-#include "superkeymonitor.h"
-
 #include "config.h"
 
 /* Register a D-Bus service for activation and deactivation of the dash */
@@ -43,7 +41,7 @@
         return false;
     }
     /* FIXME: use an adaptor class in order not to expose all of the view's
-       properties and methods. */
+       properties and methods. */\
     if (!bus.registerObject("/Dash", view, QDBusConnection::ExportAllContents)) {
         qCritical() << "Failed to register /Dash, this should not happen!";
         return false;
@@ -61,33 +59,6 @@
     return true;
 }
 
-static DashDeclarativeView* getView()
-{
-    QVariant viewProperty = QApplication::instance()->property("view");
-    return viewProperty.value<DashDeclarativeView*>();
-}
-
-static bool eventFilter(void* message)
-{
-    XEvent* event = static_cast<XEvent*>(message);
-    if (event->type == KeyRelease)
-    {
-        XKeyEvent* key = (XKeyEvent*) event;
-        uint code = key->keycode;
-        if (code == SuperKeyMonitor::SUPER_L || code == SuperKeyMonitor::SUPER_R) {
-            /* Super (aka the "windows" key) shows/hides the dash. */
-            DashDeclarativeView* view = getView();
-            if (view->active()) {
-                view->setActive(false);
-            }
-            else {
-                view->activateHome();
-            }
-        }
-    }
-    return false;
-}
-
 int main(int argc, char *argv[])
 {
     QApplication::setApplicationName("Unity 2D Dash");
@@ -142,10 +113,6 @@
     view.fitToAvailableSpace(current_screen);
     QObject::connect(QApplication::desktop(), SIGNAL(workAreaResized(int)), &view, SLOT(fitToAvailableSpace(int)));
 
-    /* Grab the "super" keys */
-    SuperKeyMonitor superKeys; /* Just needs to be instantiated to work. */
-    QAbstractEventDispatcher::instance()->setEventFilter(eventFilter);
-
     application.setProperty("view", QVariant::fromValue(&view));
     return application.exec();
 }
 
=== removed file 'places/app/superkeymonitor.cpp'
--- places/app/superkeymonitor.cpp	2011-01-11 12:47:22 +0000
+++ places/app/superkeymonitor.cpp	1970-01-01 00:00:00 +0000
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2011 Canonical, Ltd.
- *
- * Authors:
- *  Olivier Tilloy <[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 "superkeymonitor.h"
-#include "keymonitor.h"
-
-#include "gconfitem-qml-wrapper.h"
-
-SuperKeyMonitor::SuperKeyMonitor()
-{
-    m_left = new KeyMonitor(SUPER_L, this);
-    m_right = new KeyMonitor(SUPER_R, this);
-
-    m_enable_setting = new GConfItemQmlWrapper(this);
-    m_enable_setting->setKey("/desktop/unity/launcher/super_key_enable");
-    if (getEnableSettingValue()) {
-        startMonitoring();
-    }
-    connect(m_enable_setting, SIGNAL(valueChanged()), SLOT(slotEnableSettingChanged()));
-}
-
-SuperKeyMonitor::~SuperKeyMonitor()
-{
-}
-
-bool
-SuperKeyMonitor::getEnableSettingValue() const
-{
-    QVariant value = m_enable_setting->getValue();
-    if (value.isValid()) {
-        return value.toBool();
-    }
-    else {
-        /* The key is not set, assume true. */
-        return true;
-    }
-}
-
-void
-SuperKeyMonitor::slotEnableSettingChanged()
-{
-    if (getEnableSettingValue()) {
-        startMonitoring();
-    }
-    else {
-        stopMonitoring();
-    }
-}
-
-void
-SuperKeyMonitor::startMonitoring()
-{
-    m_left->grabKey();
-    m_right->grabKey();
-}
-
-void
-SuperKeyMonitor::stopMonitoring()
-{
-    m_left->ungrabKey();
-    m_right->ungrabKey();
-}
-
 
=== removed file 'places/app/superkeymonitor.h'
--- places/app/superkeymonitor.h	2011-01-11 12:35:07 +0000
+++ places/app/superkeymonitor.h	1970-01-01 00:00:00 +0000
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2011 Canonical, Ltd.
- *
- * Authors:
- *  Olivier Tilloy <[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/>.
- */
-
-#ifndef SuperKeyMonitor_H
-#define SuperKeyMonitor_H
-
-#include <QObject>
-
-class KeyMonitor;
-class GConfItemQmlWrapper;
-
-class SuperKeyMonitor : public QObject
-{
-    Q_OBJECT
-
-public:
-    SuperKeyMonitor();
-    ~SuperKeyMonitor();
-
-    static const uint SUPER_L = 133;
-    static const uint SUPER_R = 134;
-
-private:
-    KeyMonitor* m_left;
-    KeyMonitor* m_right;
-
-    GConfItemQmlWrapper* m_enable_setting;
-
-    bool getEnableSettingValue() const;
-
-    void startMonitoring();
-    void stopMonitoring();
-
-private Q_SLOTS:
-    void slotEnableSettingChanged();
-};
-
-#endif // SuperKeyMonitor_H
-