diff --git a/autotests/integration/globalshortcuts_test.cpp b/autotests/integration/globalshortcuts_test.cpp
index 6a4024f00..c17721bd1 100644
--- a/autotests/integration/globalshortcuts_test.cpp
+++ b/autotests/integration/globalshortcuts_test.cpp
@@ -1,362 +1,382 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 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; either version 2 of the License, or
 (at your option) any later version.
 
 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 "kwin_wayland_test.h"
 #include "client.h"
 #include "cursor.h"
 #include "input.h"
 #include "platform.h"
 #include "screens.h"
 #include "shell_client.h"
 #include "useractions.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/shell.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/seat_interface.h>
 
 #include <KGlobalAccel>
 #include <linux/input.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_globalshortcuts-0");
 
 class GlobalShortcutsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testConsumedShift();
     void testRepeatedTrigger();
     void testUserActionsMenu();
     void testMetaShiftW();
+    void testComponseKey();
     void testX11ClientShortcut();
     void testWaylandClientShortcut();
     void testSetupWindowShortcut();
 };
 
 void GlobalShortcutsTest::initTestCase()
 {
     qRegisterMetaType<KWin::ShellClient*>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     qputenv("KWIN_XKB_DEFAULT_KEYMAP", "1");
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void GlobalShortcutsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(640, 512));
 }
 
 void GlobalShortcutsTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void GlobalShortcutsTest::testConsumedShift()
 {
     // this test verifies that a shortcut with a consumed shift modifier triggers
     // create the action
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-consumed-shift"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::Key_Percent}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::Key_Percent, action.data());
 
     // press shift+5
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_5, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     kwinApp()->platform()->keyboardKeyReleased(KEY_5, timestamp++);
 
     // release shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
 }
 
 void GlobalShortcutsTest::testRepeatedTrigger()
 {
     // this test verifies that holding a key, triggers repeated global shortcut
     // in addition pressing another key should stop triggering the shortcut
 
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-consumed-shift"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::Key_Percent}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::Key_Percent, action.data());
 
     // we need to configure the key repeat first. It is only enabled on libinput
     waylandServer()->seat()->setKeyRepeatInfo(25, 300);
 
     // press shift+5
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_WAKEUP, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_5, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     // and should repeat
     QVERIFY(triggeredSpy.wait());
     QVERIFY(triggeredSpy.wait());
     // now release the key
     kwinApp()->platform()->keyboardKeyReleased(KEY_5, timestamp++);
     QVERIFY(!triggeredSpy.wait(500));
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_WAKEUP, timestamp++);
     QVERIFY(!triggeredSpy.wait(500));
 
     // release shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
 }
 
 void GlobalShortcutsTest::testUserActionsMenu()
 {
     // this test tries to trigger the user actions menu with Alt+F3
     // the problem here is that pressing F3 consumes modifiers as it's part of the
     // Ctrl+alt+F3 keysym for vt switching. xkbcommon considers all modifiers as consumed
     // which a transformation to any keysym would cause
     // for more information see:
     // https://bugs.freedesktop.org/show_bug.cgi?id=92818
     // https://github.com/xkbcommon/libxkbcommon/issues/17
 
     // first create a window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
 
     quint32 timestamp = 0;
     QVERIFY(!workspace()->userActionsMenu()->isShown());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_F3, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_F3, timestamp++);
     QTRY_VERIFY(workspace()->userActionsMenu()->isShown());
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 }
 
 void GlobalShortcutsTest::testMetaShiftW()
 {
     // BUG 370341
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-meta-shift-w"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::META + Qt::SHIFT + Qt::Key_W}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::META + Qt::SHIFT + Qt::Key_W, action.data());
 
     // press meta+shift+w
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::MetaModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier | Qt::MetaModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_W, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     kwinApp()->platform()->keyboardKeyReleased(KEY_W, timestamp++);
 
     // release meta+shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 }
 
+void GlobalShortcutsTest::testComponseKey()
+{
+    // BUG 390110
+    QScopedPointer<QAction> action(new QAction(nullptr));
+    action->setProperty("componentName", QStringLiteral(KWIN_NAME));
+    action->setObjectName(QStringLiteral("globalshortcuts-accent"));
+    QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
+    QVERIFY(triggeredSpy.isValid());
+    KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::UNICODE_ACCEL}, KGlobalAccel::NoAutoloading);
+    input()->registerShortcut(Qt::UNICODE_ACCEL, action.data());
+
+    // press & release `
+    quint32 timestamp = 0;
+    kwinApp()->platform()->keyboardKeyPressed(KEY_RESERVED, timestamp++);
+    kwinApp()->platform()->keyboardKeyReleased(KEY_RESERVED, timestamp++);
+
+    QTRY_COMPARE(triggeredSpy.count(), 0);
+}
+
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void GlobalShortcutsTest::testX11ClientShortcut()
 {
     // create an X11 window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 10, 20);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     Client *client = windowCreatedSpy.last().first().value<Client*>();
     QVERIFY(client);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
     const QKeySequence seq(Qt::META + Qt::SHIFT + Qt::Key_Y);
     QVERIFY(workspace()->shortcutAvailable(seq));
     client->setShortcut(seq.toString());
     QCOMPARE(client->shortcut(), seq);
     QVERIFY(!workspace()->shortcutAvailable(seq));
     QCOMPARE(client->caption(), QStringLiteral(" {Meta+Shift+Y}"));
 
     // it's delayed
     QCoreApplication::processEvents();
 
     workspace()->activateClient(nullptr);
     QVERIFY(!workspace()->activeClient());
     QVERIFY(!client->isActive());
 
     // now let's trigger the shortcut
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     QTRY_COMPARE(workspace()->activeClient(), client);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void GlobalShortcutsTest::testWaylandClientShortcut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
     const QKeySequence seq(Qt::META + Qt::SHIFT + Qt::Key_Y);
     QVERIFY(workspace()->shortcutAvailable(seq));
     client->setShortcut(seq.toString());
     QCOMPARE(client->shortcut(), seq);
     QVERIFY(!workspace()->shortcutAvailable(seq));
     QCOMPARE(client->caption(), QStringLiteral(" {Meta+Shift+Y}"));
 
     workspace()->activateClient(nullptr);
     QVERIFY(!workspace()->activeClient());
     QVERIFY(!client->isActive());
 
     // now let's trigger the shortcut
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     QTRY_COMPARE(workspace()->activeClient(), client);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QVERIFY(workspace()->shortcutAvailable(seq));
 }
 
 void GlobalShortcutsTest::testSetupWindowShortcut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
 
     QSignalSpy shortcutDialogAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(shortcutDialogAddedSpy.isValid());
     workspace()->slotSetupWindowShortcut();
     QTRY_COMPARE(shortcutDialogAddedSpy.count(), 1);
     auto dialog = shortcutDialogAddedSpy.first().first().value<ShellClient*>();
     QVERIFY(dialog);
     QVERIFY(dialog->isInternal());
     auto sequenceEdit = workspace()->shortcutDialog()->findChild<QKeySequenceEdit*>();
     QVERIFY(sequenceEdit);
 
     // the QKeySequenceEdit field does not get focus, we need to pass it focus manually
     QEXPECT_FAIL("", "Edit does not have focus", Continue);
     QVERIFY(sequenceEdit->hasFocus());
     sequenceEdit->setFocus();
     QTRY_VERIFY(sequenceEdit->hasFocus());
 
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     // the sequence gets accepted after one second, so wait a bit longer
     QTest::qWait(2000);
     // now send in enter
     kwinApp()->platform()->keyboardKeyPressed(KEY_ENTER, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ENTER, timestamp++);
     QTRY_COMPARE(client->shortcut(), QKeySequence(Qt::META + Qt::SHIFT + Qt::Key_Y));
 }
 
 WAYLANDTEST_MAIN(GlobalShortcutsTest)
 #include "globalshortcuts_test.moc"
diff --git a/globalshortcuts.cpp b/globalshortcuts.cpp
index 89fc63235..970c79fbf 100644
--- a/globalshortcuts.cpp
+++ b/globalshortcuts.cpp
@@ -1,309 +1,312 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 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; either version 2 of the License, or
 (at your option) any later version.
 
 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/>.
 *********************************************************************/
 // own
 #include "globalshortcuts.h"
 // kwin
 #include <config-kwin.h>
 #include "main.h"
 #include "gestures.h"
 #include "utils.h"
 // KDE
 #include <KGlobalAccel/private/kglobalacceld.h>
 #include <KGlobalAccel/private/kglobalaccel_interface.h>
 // Qt
 #include <QAction>
 
 namespace KWin
 {
 
 uint qHash(SwipeDirection direction)
 {
     return uint(direction);
 }
 
 GlobalShortcut::GlobalShortcut(const QKeySequence &shortcut)
     : m_shortcut(shortcut)
     , m_pointerModifiers(Qt::NoModifier)
     , m_pointerButtons(Qt::NoButton)
 {
 }
 
 GlobalShortcut::GlobalShortcut(Qt::KeyboardModifiers pointerButtonModifiers, Qt::MouseButtons pointerButtons)
     : m_shortcut(QKeySequence())
     , m_pointerModifiers(pointerButtonModifiers)
     , m_pointerButtons(pointerButtons)
 {
 }
 
 GlobalShortcut::GlobalShortcut(Qt::KeyboardModifiers modifiers)
     : m_shortcut(QKeySequence())
     , m_pointerModifiers(modifiers)
     , m_pointerButtons(Qt::NoButton)
 {
 }
 
 GlobalShortcut::GlobalShortcut(SwipeDirection direction)
     : m_shortcut(QKeySequence())
     , m_pointerModifiers(Qt::NoModifier)
     , m_pointerButtons(Qt::NoButton)
     , m_swipeDirection(direction)
 {
 }
 
 GlobalShortcut::~GlobalShortcut()
 {
 }
 
 InternalGlobalShortcut::InternalGlobalShortcut(Qt::KeyboardModifiers modifiers, const QKeySequence &shortcut, QAction *action)
     : GlobalShortcut(shortcut)
     , m_action(action)
 {
     Q_UNUSED(modifiers)
 }
 
 InternalGlobalShortcut::InternalGlobalShortcut(Qt::KeyboardModifiers pointerButtonModifiers, Qt::MouseButtons pointerButtons, QAction *action)
     : GlobalShortcut(pointerButtonModifiers, pointerButtons)
     , m_action(action)
 {
 }
 
 InternalGlobalShortcut::InternalGlobalShortcut(Qt::KeyboardModifiers axisModifiers, PointerAxisDirection axis, QAction *action)
     : GlobalShortcut(axisModifiers)
     , m_action(action)
 {
     Q_UNUSED(axis)
 }
 
 static SwipeGesture::Direction toSwipeDirection(SwipeDirection direction)
 {
     switch (direction) {
     case SwipeDirection::Up:
         return SwipeGesture::Direction::Up;
     case SwipeDirection::Down:
         return SwipeGesture::Direction::Down;
     case SwipeDirection::Left:
         return SwipeGesture::Direction::Left;
     case SwipeDirection::Right:
         return SwipeGesture::Direction::Right;
     case SwipeDirection::Invalid:
     default:
         Q_UNREACHABLE();
     }
 }
 
 InternalGlobalShortcut::InternalGlobalShortcut(Qt::KeyboardModifiers swipeModifier, SwipeDirection direction, QAction *action)
     : GlobalShortcut(direction)
     , m_action(action)
     , m_swipe(new SwipeGesture)
 {
     Q_UNUSED(swipeModifier)
     m_swipe->setDirection(toSwipeDirection(direction));
     m_swipe->setMinimumFingerCount(4);
     m_swipe->setMaximumFingerCount(4);
     QObject::connect(m_swipe.data(), &SwipeGesture::triggered, m_action, &QAction::trigger, Qt::QueuedConnection);
 }
 
 InternalGlobalShortcut::~InternalGlobalShortcut()
 {
 }
 
 void InternalGlobalShortcut::invoke()
 {
     // using QueuedConnection so that we finish the even processing first
     QMetaObject::invokeMethod(m_action, "trigger", Qt::QueuedConnection);
 }
 
 GlobalShortcutsManager::GlobalShortcutsManager(QObject *parent)
     : QObject(parent)
     , m_gestureRecognizer(new GestureRecognizer(this))
 {
 }
 
 template <typename T>
 void clearShortcuts(T &shortcuts)
 {
     for (auto it = shortcuts.begin(); it != shortcuts.end(); ++it) {
         qDeleteAll((*it));
     }
 }
 
 GlobalShortcutsManager::~GlobalShortcutsManager()
 {
     clearShortcuts(m_pointerShortcuts);
     clearShortcuts(m_axisShortcuts);
     clearShortcuts(m_swipeShortcuts);
 }
 
 void GlobalShortcutsManager::init()
 {
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         qputenv("KGLOBALACCELD_PLATFORM", QByteArrayLiteral("org.kde.kwin"));
         m_kglobalAccel = new KGlobalAccelD(this);
         if (!m_kglobalAccel->init()) {
             qCDebug(KWIN_CORE) << "Init of kglobalaccel failed";
             delete m_kglobalAccel;
             m_kglobalAccel = nullptr;
         } else {
             qCDebug(KWIN_CORE) << "KGlobalAcceld inited";
         }
     }
 }
 
 template <typename T>
 void handleDestroyedAction(QObject *object, T &shortcuts)
 {
     for (auto it = shortcuts.begin(); it != shortcuts.end(); ++it) {
         auto &list = it.value();
         auto it2 = list.begin();
         while (it2 != list.end()) {
             if (InternalGlobalShortcut *shortcut = dynamic_cast<InternalGlobalShortcut*>(it2.value())) {
                 if (shortcut->action() == object) {
                     it2 = list.erase(it2);
                     delete shortcut;
                     continue;
                 }
             }
             ++it2;
         }
     }
 }
 
 void GlobalShortcutsManager::objectDeleted(QObject *object)
 {
     handleDestroyedAction(object, m_pointerShortcuts);
     handleDestroyedAction(object, m_axisShortcuts);
     handleDestroyedAction(object, m_swipeShortcuts);
 }
 
 template <typename T, typename R>
 GlobalShortcut *addShortcut(T &shortcuts, QAction *action, Qt::KeyboardModifiers modifiers, R value)
 {
     GlobalShortcut *cut = new InternalGlobalShortcut(modifiers, value, action);
     auto it = shortcuts.find(modifiers);
     if (it != shortcuts.end()) {
         // TODO: check if shortcut already exists
         (*it).insert(value, cut);
     } else {
         QHash<R, GlobalShortcut*> s;
         s.insert(value, cut);
         shortcuts.insert(modifiers, s);
     }
     return cut;
 }
 
 void GlobalShortcutsManager::registerPointerShortcut(QAction *action, Qt::KeyboardModifiers modifiers, Qt::MouseButtons pointerButtons)
 {
     addShortcut(m_pointerShortcuts, action, modifiers, pointerButtons);
     connect(action, &QAction::destroyed, this, &GlobalShortcutsManager::objectDeleted);
 }
 
 void GlobalShortcutsManager::registerAxisShortcut(QAction *action, Qt::KeyboardModifiers modifiers, PointerAxisDirection axis)
 {
     addShortcut(m_axisShortcuts, action, modifiers, axis);
     connect(action, &QAction::destroyed, this, &GlobalShortcutsManager::objectDeleted);
 }
 
 void GlobalShortcutsManager::registerTouchpadSwipe(QAction *action, SwipeDirection direction)
 {
     auto shortcut = addShortcut(m_swipeShortcuts, action, Qt::NoModifier, direction);
     connect(action, &QAction::destroyed, this, &GlobalShortcutsManager::objectDeleted);
     m_gestureRecognizer->registerGesture(static_cast<InternalGlobalShortcut*>(shortcut)->swipeGesture());
 }
 
 template <typename T, typename U>
 bool processShortcut(Qt::KeyboardModifiers mods, T key, U &shortcuts)
 {
     auto it = shortcuts.find(mods);
     if (it == shortcuts.end()) {
         return false;
     }
     auto it2 = (*it).find(key);
     if (it2 == (*it).end()) {
         return false;
     }
     it2.value()->invoke();
     return true;
 }
 
 bool GlobalShortcutsManager::processKey(Qt::KeyboardModifiers mods, int keyQt)
 {
     if (m_kglobalAccelInterface) {
+        if (!keyQt && !mods) {
+            return false;
+        }
         auto check = [this] (Qt::KeyboardModifiers mods, int keyQt) {
             bool retVal = false;
             QMetaObject::invokeMethod(m_kglobalAccelInterface,
                                         "checkKeyPressed",
                                         Qt::DirectConnection,
                                         Q_RETURN_ARG(bool, retVal),
                                         Q_ARG(int, int(mods) | keyQt));
             return retVal;
         };
         if (check(mods, keyQt)) {
             return true;
         } else if (keyQt == Qt::Key_Backtab) {
             // KGlobalAccel on X11 has some workaround for Backtab
             // see kglobalaccel/src/runtime/plugins/xcb/kglobalccel_x11.cpp method x11KeyPress
             // Apparently KKeySequenceWidget captures Shift+Tab instead of Backtab
             // thus if the key is backtab we should adjust to add shift again and use tab
             // in addition KWin registers the shortcut incorrectly as Alt+Shift+Backtab
             // this should be changed to either Alt+Backtab or Alt+Shift+Tab to match KKeySequenceWidget
             // trying the variants
             if (check(mods | Qt::ShiftModifier, keyQt)) {
                 return true;
             }
             if (check(mods | Qt::ShiftModifier, Qt::Key_Tab)) {
                 return true;
             }
         }
     }
     return false;
 }
 
 bool GlobalShortcutsManager::processPointerPressed(Qt::KeyboardModifiers mods, Qt::MouseButtons pointerButtons)
 {
     return processShortcut(mods, pointerButtons, m_pointerShortcuts);
 }
 
 bool GlobalShortcutsManager::processAxis(Qt::KeyboardModifiers mods, PointerAxisDirection axis)
 {
     return processShortcut(mods, axis, m_axisShortcuts);
 }
 
 void GlobalShortcutsManager::processSwipeStart(uint fingerCount)
 {
     m_gestureRecognizer->startSwipeGesture(fingerCount);
 }
 
 void GlobalShortcutsManager::processSwipeUpdate(const QSizeF &delta)
 {
     m_gestureRecognizer->updateSwipeGesture(delta);
 }
 
 void GlobalShortcutsManager::processSwipeCancel()
 {
     m_gestureRecognizer->cancelSwipeGesture();
 }
 
 void GlobalShortcutsManager::processSwipeEnd()
 {
     m_gestureRecognizer->endSwipeGesture();
     // TODO: cancel on Wayland Seat if one triggered
 }
 
 } // namespace