yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/integration/modifier_only_shortcut_test.cpp

387 lines
16 KiB
C++
Raw Normal View History

[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
/********************************************************************
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 "cursor.h"
[autotest/integration] Add pointer button events to ModifiersOnlyShortcutTest If a pointer button is pressed or gets pressed while a modifier is hold, the modifier only shortcuts should not trigger. The user wanted to use the modifier for the pointer button. This is not implemented yet, thus all is QEXPECT_FAIL.
2016-08-13 13:09:21 +00:00
#include "input.h"
[autotests] Add test case for modifier only trigger when capslock enabled This extends the testCapsLock to ensure that modifier only shortcut trigger when capslock is enabled. So far the test only ensured that capslock doesn't trigger the shift modifier only shortcut. As the test shows currently when capslock is on, the meta key doesn't trigger any more. CCBUG: 375355
2017-01-21 19:13:09 +00:00
#include "keyboard_input.h"
[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
#include "platform.h"
#include "screens.h"
#include "wayland_server.h"
#include "workspace.h"
#include <KConfigGroup>
#include <QDBusConnection>
#include <linux/input.h>
using namespace KWin;
using namespace KWayland::Client;
static const QString s_socketName = QStringLiteral("wayland_test_kwin_modifier_only_shortcut-0");
static const QString s_serviceName = QStringLiteral("org.kde.KWin.Test.ModifierOnlyShortcut");
static const QString s_path = QStringLiteral("/Test");
class ModifierOnlyShortcutTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testTrigger_data();
void testTrigger();
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
void testCapsLock();
Test case for mod only shortcut with global shortcuts disabled KWin supports disabling global shortcuts while a specific window is active through window rules. This blocks global shortcuts but does not block the modifier-only-shortcuts as the new test case shows. CCBUG: 370146
2016-10-06 05:36:12 +00:00
void testGlobalShortcutsDisabled_data();
void testGlobalShortcutsDisabled();
[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
};
class Target : public QObject
{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.kde.KWin.Test.ModifierOnlyShortcut")
public:
Target();
Run clang-tidy with modernize-use-override check Summary: Currently code base of kwin can be viewed as two pieces. One is very ancient, and the other one is more modern, which uses new C++ features. The main problem with the ancient code is that it was written before C++11 era. So, no override or final keywords, lambdas, etc. Quite recently, KDE compiler settings were changed to show a warning if a virtual method has missing override keyword. As you might have already guessed, this fired back at us because of that ancient code. We had about 500 new compiler warnings. A "solution" was proposed to that problem - disable -Wno-suggest-override and the other similar warning for clang. It's hard to call a solution because those warnings are disabled not only for the old code, but also for new. This is not what we want! The main argument for not actually fixing the problem was that git history will be screwed as well because of human factor. While good git history is a very important thing, we should not go crazy about it and block every change that somehow alters git history. git blame allows to specify starting revision for a reason. The other argument (human factor) can be easily solved by using tools such as clang-tidy. clang-tidy is a clang-based linter for C++. It can be used for various things, e.g. fixing coding style(e.g. add missing braces to if statements, readability-braces-around-statements check), or in our case add missing override keywords. Test Plan: Compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, apol, romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22371
2019-07-22 16:52:26 +00:00
~Target() override;
[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
public Q_SLOTS:
Q_SCRIPTABLE void shortcut();
Q_SIGNALS:
void shortcutTriggered();
};
Target::Target()
: QObject()
{
QDBusConnection::sessionBus().registerService(s_serviceName);
QDBusConnection::sessionBus().registerObject(s_path, s_serviceName, this, QDBusConnection::ExportScriptableSlots);
}
Target::~Target()
{
QDBusConnection::sessionBus().unregisterObject(s_path);
QDBusConnection::sessionBus().unregisterService(s_serviceName);
}
void Target::shortcut()
{
emit shortcutTriggered();
}
void ModifierOnlyShortcutTest::initTestCase()
{
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));
Introduce env variable KWIN_XKB_DEFAULT_KEYMAP to force default layout creation Summary: The Xkb class loads keyboard layouts from the users configuration. This makes tests fail locally if the user has a layout which behaves differently to the one the test expects. E.g. on a German layout the right alt key is different to the one of US layout. In order to have a more stable test base the env variable KWIN_XKB_DEFAULT_KEYMAP forces the loading of the default keymap, thus tests have a common layout set. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2466
2016-08-17 06:35:15 +00:00
qputenv("KWIN_XKB_DEFAULT_KEYMAP", "1");
[autotests] Force XKB_DEFAULT_RULES to evdev in ModifierOnlyShortcutsTest This is an idea to fix the failing test on FreeBSD (see T6624). For Linux this does not change anything.
2017-09-17 18:54:32 +00:00
qputenv("XKB_DEFAULT_RULES", "evdev");
[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());
waylandServer()->initWorkspace();
}
void ModifierOnlyShortcutTest::init()
{
screens()->setCurrent(0);
KWin::Cursor::setPos(QPoint(640, 512));
}
void ModifierOnlyShortcutTest::cleanup()
{
}
void ModifierOnlyShortcutTest::testTrigger_data()
{
QTest::addColumn<QStringList>("metaConfig");
QTest::addColumn<QStringList>("altConfig");
QTest::addColumn<QStringList>("controlConfig");
QTest::addColumn<QStringList>("shiftConfig");
QTest::addColumn<int>("modifier");
QTest::addColumn<QList<int>>("nonTriggeringMods");
const QStringList trigger = QStringList{s_serviceName, s_path, s_serviceName, QStringLiteral("shortcut")};
const QStringList e = QStringList();
QTest::newRow("leftMeta") << trigger << e << e << e << KEY_LEFTMETA << QList<int>{KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTSHIFT, KEY_RIGHTSHIFT};
QTest::newRow("rightMeta") << trigger << e << e << e << KEY_RIGHTMETA << QList<int>{KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTSHIFT, KEY_RIGHTSHIFT};
QTest::newRow("leftAlt") << e << trigger << e << e << KEY_LEFTALT << QList<int>{KEY_LEFTMETA, KEY_RIGHTMETA, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTSHIFT, KEY_RIGHTSHIFT};
QTest::newRow("rightAlt") << e << trigger << e << e << KEY_RIGHTALT << QList<int>{KEY_LEFTMETA, KEY_RIGHTMETA, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTSHIFT, KEY_RIGHTSHIFT};
QTest::newRow("leftControl") << e << e << trigger << e << KEY_LEFTCTRL << QList<int>{KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTMETA, KEY_RIGHTMETA, KEY_LEFTSHIFT, KEY_RIGHTSHIFT};
QTest::newRow("rightControl") << e << e << trigger << e << KEY_RIGHTCTRL << QList<int>{KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTMETA, KEY_RIGHTMETA, KEY_LEFTSHIFT, KEY_RIGHTSHIFT};
QTest::newRow("leftShift") << e << e << e << trigger << KEY_LEFTSHIFT << QList<int>{KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTMETA, KEY_RIGHTMETA};
QTest::newRow("rightShift") << e << e << e << trigger <<KEY_RIGHTSHIFT << QList<int>{KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTMETA, KEY_RIGHTMETA};
}
void ModifierOnlyShortcutTest::testTrigger()
{
// this test verifies that modifier only shortcut triggers correctly
Target target;
QSignalSpy triggeredSpy(&target, &Target::shortcutTriggered);
QVERIFY(triggeredSpy.isValid());
KConfigGroup group = kwinApp()->config()->group("ModifierOnlyShortcuts");
QFETCH(QStringList, metaConfig);
QFETCH(QStringList, altConfig);
QFETCH(QStringList, shiftConfig);
QFETCH(QStringList, controlConfig);
group.writeEntry("Meta", metaConfig);
group.writeEntry("Alt", altConfig);
group.writeEntry("Shift", shiftConfig);
group.writeEntry("Control", controlConfig);
group.sync();
workspace()->slotReconfigure();
// configured shortcut should trigger
quint32 timestamp = 1;
QFETCH(int, modifier);
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 1);
// the other shortcuts should not trigger
QFETCH(QList<int>, nonTriggeringMods);
for (auto it = nonTriggeringMods.constBegin(), end = nonTriggeringMods.constEnd(); it != end; it++) {
kwinApp()->platform()->keyboardKeyPressed(*it, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(*it, timestamp++);
QCOMPARE(triggeredSpy.count(), 1);
}
// try configured again
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
// click another key while modifier is held
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
// release other key after modifier release
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
// press key before pressing modifier
kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
[autotest/integration] Add pointer button events to ModifiersOnlyShortcutTest If a pointer button is pressed or gets pressed while a modifier is hold, the modifier only shortcuts should not trigger. The user wanted to use the modifier for the pointer button. This is not implemented yet, thus all is QEXPECT_FAIL.
2016-08-13 13:09:21 +00:00
// mouse button pressed before clicking modifier
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
QCOMPARE(input()->qtButtonStates(), Qt::LeftButton);
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
QCOMPARE(input()->qtButtonStates(), Qt::NoButton);
QCOMPARE(triggeredSpy.count(), 2);
// mouse button press before mod press, release before mod release
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
QCOMPARE(input()->qtButtonStates(), Qt::LeftButton);
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(input()->qtButtonStates(), Qt::NoButton);
QCOMPARE(triggeredSpy.count(), 2);
// mouse button click while mod is pressed
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
QCOMPARE(input()->qtButtonStates(), Qt::LeftButton);
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(input()->qtButtonStates(), Qt::NoButton);
QCOMPARE(triggeredSpy.count(), 2);
[autotest/integration] Add pointer axis events to ModifiersOnlyShortcutTest If a pointer axis is scrolled while a modifier is hold, the modifier only shortcuts should not trigger. The user wanted to use the modifier for the pointer axis. This is not implemented yet, thus all is QEXPECT_FAIL.
2016-08-13 13:15:54 +00:00
// scroll while mod is pressed
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
// same for horizontal
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
[autotests/integration] Test case for screen locked with mod-only-shortcuts Currently expected failures as modifier only shortcuts don't check for locked screen yet.
2016-08-16 06:19:45 +00:00
// now try to lock the screen while modifier key is pressed
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
QVERIFY(Test::lockScreen());
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
// now trigger while screen is locked, should also not work
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 2);
QVERIFY(Test::unlockScreen());
[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
}
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
void ModifierOnlyShortcutTest::testCapsLock()
{
// this test verifies that Capslock does not trigger the shift shortcut
Support modifier-only-shortcuts when capslock is on Summary: So far we didn't trigger modifier-only-shortcuts when capslock was enabled. In fact we even ensured that the shortcuts did not trigger. This seems not to be what our users expect. Meta should still trigger if capslock is on. This change modifies the logic to determine which modifier is currently pressed by using the modifiersRelevantForGlobalShortcuts. The difference to the "normal" modifiers is that this excludes capslock from modifiers and excludes consumed modifiers. The latter is not really relevant as modifier-only-shortcuts do not trigger if multiple keys are pressed, which is required to have a modifier consumed. BUG: 375355 FIXED-IN: 5.8.6 Test Plan: Only with adjusted autotest Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D4241
2017-01-22 08:44:15 +00:00
// but other shortcuts still trigger even when Capslock is on
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
Target target;
QSignalSpy triggeredSpy(&target, &Target::shortcutTriggered);
QVERIFY(triggeredSpy.isValid());
KConfigGroup group = kwinApp()->config()->group("ModifierOnlyShortcuts");
group.writeEntry("Meta", QStringList());
group.writeEntry("Alt", QStringList());
group.writeEntry("Shift", QStringList{s_serviceName, s_path, s_serviceName, QStringLiteral("shortcut")});
group.writeEntry("Control", QStringList());
group.sync();
workspace()->slotReconfigure();
// first test that the normal shortcut triggers
quint32 timestamp = 1;
const int modifier = KEY_LEFTSHIFT;
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 1);
// now capslock
kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
QCOMPARE(triggeredSpy.count(), 1);
// currently caps lock is on
Support modifier-only-shortcuts when capslock is on Summary: So far we didn't trigger modifier-only-shortcuts when capslock was enabled. In fact we even ensured that the shortcuts did not trigger. This seems not to be what our users expect. Meta should still trigger if capslock is on. This change modifies the logic to determine which modifier is currently pressed by using the modifiersRelevantForGlobalShortcuts. The difference to the "normal" modifiers is that this excludes capslock from modifiers and excludes consumed modifiers. The latter is not really relevant as modifier-only-shortcuts do not trigger if multiple keys are pressed, which is required to have a modifier consumed. BUG: 375355 FIXED-IN: 5.8.6 Test Plan: Only with adjusted autotest Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D4241
2017-01-22 08:44:15 +00:00
// shift still triggers
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
Support modifier-only-shortcuts when capslock is on Summary: So far we didn't trigger modifier-only-shortcuts when capslock was enabled. In fact we even ensured that the shortcuts did not trigger. This seems not to be what our users expect. Meta should still trigger if capslock is on. This change modifies the logic to determine which modifier is currently pressed by using the modifiersRelevantForGlobalShortcuts. The difference to the "normal" modifiers is that this excludes capslock from modifiers and excludes consumed modifiers. The latter is not really relevant as modifier-only-shortcuts do not trigger if multiple keys are pressed, which is required to have a modifier consumed. BUG: 375355 FIXED-IN: 5.8.6 Test Plan: Only with adjusted autotest Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D4241
2017-01-22 08:44:15 +00:00
QCOMPARE(triggeredSpy.count(), 2);
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
Support modifier-only-shortcuts when capslock is on Summary: So far we didn't trigger modifier-only-shortcuts when capslock was enabled. In fact we even ensured that the shortcuts did not trigger. This seems not to be what our users expect. Meta should still trigger if capslock is on. This change modifies the logic to determine which modifier is currently pressed by using the modifiersRelevantForGlobalShortcuts. The difference to the "normal" modifiers is that this excludes capslock from modifiers and excludes consumed modifiers. The latter is not really relevant as modifier-only-shortcuts do not trigger if multiple keys are pressed, which is required to have a modifier consumed. BUG: 375355 FIXED-IN: 5.8.6 Test Plan: Only with adjusted autotest Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D4241
2017-01-22 08:44:15 +00:00
// meta should also trigger
[autotests] Add test case for modifier only trigger when capslock enabled This extends the testCapsLock to ensure that modifier only shortcut trigger when capslock is enabled. So far the test only ensured that capslock doesn't trigger the shift modifier only shortcut. As the test shows currently when capslock is on, the meta key doesn't trigger any more. CCBUG: 375355
2017-01-21 19:13:09 +00:00
group.writeEntry("Meta", QStringList{s_serviceName, s_path, s_serviceName, QStringLiteral("shortcut")});
group.writeEntry("Alt", QStringList());
group.writeEntry("Shift", QStringList{});
group.writeEntry("Control", QStringList());
group.sync();
workspace()->slotReconfigure();
kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier | Qt::MetaModifier);
QCOMPARE(input()->keyboard()->xkb()->modifiersRelevantForGlobalShortcuts(), Qt::MetaModifier);
kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
Support modifier-only-shortcuts when capslock is on Summary: So far we didn't trigger modifier-only-shortcuts when capslock was enabled. In fact we even ensured that the shortcuts did not trigger. This seems not to be what our users expect. Meta should still trigger if capslock is on. This change modifies the logic to determine which modifier is currently pressed by using the modifiersRelevantForGlobalShortcuts. The difference to the "normal" modifiers is that this excludes capslock from modifiers and excludes consumed modifiers. The latter is not really relevant as modifier-only-shortcuts do not trigger if multiple keys are pressed, which is required to have a modifier consumed. BUG: 375355 FIXED-IN: 5.8.6 Test Plan: Only with adjusted autotest Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D4241
2017-01-22 08:44:15 +00:00
QCOMPARE(triggeredSpy.count(), 3);
// set back to shift to ensure we don't trigger with capslock
group.writeEntry("Meta", QStringList());
group.writeEntry("Alt", QStringList());
group.writeEntry("Shift", QStringList{s_serviceName, s_path, s_serviceName, QStringLiteral("shortcut")});
group.writeEntry("Control", QStringList());
group.sync();
workspace()->slotReconfigure();
[autotests] Add test case for modifier only trigger when capslock enabled This extends the testCapsLock to ensure that modifier only shortcut trigger when capslock is enabled. So far the test only ensured that capslock doesn't trigger the shift modifier only shortcut. As the test shows currently when capslock is on, the meta key doesn't trigger any more. CCBUG: 375355
2017-01-21 19:13:09 +00:00
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
// release caps lock
kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
QCOMPARE(input()->keyboardModifiers(), Qt::NoModifier);
Support modifier-only-shortcuts when capslock is on Summary: So far we didn't trigger modifier-only-shortcuts when capslock was enabled. In fact we even ensured that the shortcuts did not trigger. This seems not to be what our users expect. Meta should still trigger if capslock is on. This change modifies the logic to determine which modifier is currently pressed by using the modifiersRelevantForGlobalShortcuts. The difference to the "normal" modifiers is that this excludes capslock from modifiers and excludes consumed modifiers. The latter is not really relevant as modifier-only-shortcuts do not trigger if multiple keys are pressed, which is required to have a modifier consumed. BUG: 375355 FIXED-IN: 5.8.6 Test Plan: Only with adjusted autotest Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D4241
2017-01-22 08:44:15 +00:00
QCOMPARE(triggeredSpy.count(), 3);
Ensure modifier locks and latches don't trigger the mod only shortcut Summary: If caps lock is on the shift key should not trigger. Similar pressing caps lock should neither on activation press nor on deactivation press trigger the shortcut. Related to that are latched modifiers aka sticky modifiers: if the modifier is still on after releasing the key the shortcut should not trigger. We must assume the user wanted to use the modifier to activate the modifier, not to activate the shortcut. This change ensures that we don't track for modifier only shortcuts if a modifier is active before press or after release. The added test case demonstrates for caps lock, latched modifiers is currently still untested. (Needs a way to mock it). Test Plan: See test case for caps lock. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2467
2016-08-17 06:39:51 +00:00
}
Test case for mod only shortcut with global shortcuts disabled KWin supports disabling global shortcuts while a specific window is active through window rules. This blocks global shortcuts but does not block the modifier-only-shortcuts as the new test case shows. CCBUG: 370146
2016-10-06 05:36:12 +00:00
void ModifierOnlyShortcutTest::testGlobalShortcutsDisabled_data()
{
QTest::addColumn<QStringList>("metaConfig");
QTest::addColumn<QStringList>("altConfig");
QTest::addColumn<QStringList>("controlConfig");
QTest::addColumn<QStringList>("shiftConfig");
QTest::addColumn<int>("modifier");
const QStringList trigger = QStringList{s_serviceName, s_path, s_serviceName, QStringLiteral("shortcut")};
const QStringList e = QStringList();
QTest::newRow("leftMeta") << trigger << e << e << e << KEY_LEFTMETA;
QTest::newRow("rightMeta") << trigger << e << e << e << KEY_RIGHTMETA;
QTest::newRow("leftAlt") << e << trigger << e << e << KEY_LEFTALT;
QTest::newRow("rightAlt") << e << trigger << e << e << KEY_RIGHTALT;
QTest::newRow("leftControl") << e << e << trigger << e << KEY_LEFTCTRL;
QTest::newRow("rightControl") << e << e << trigger << e << KEY_RIGHTCTRL;
QTest::newRow("leftShift") << e << e << e << trigger << KEY_LEFTSHIFT;
QTest::newRow("rightShift") << e << e << e << trigger <<KEY_RIGHTSHIFT;
}
void ModifierOnlyShortcutTest::testGlobalShortcutsDisabled()
{
// this test verifies that when global shortcuts are disabled inside KWin (e.g. through a window rule)
// the modifier only shortcuts do not trigger.
// see BUG: 370146
Target target;
QSignalSpy triggeredSpy(&target, &Target::shortcutTriggered);
QVERIFY(triggeredSpy.isValid());
KConfigGroup group = kwinApp()->config()->group("ModifierOnlyShortcuts");
QFETCH(QStringList, metaConfig);
QFETCH(QStringList, altConfig);
QFETCH(QStringList, shiftConfig);
QFETCH(QStringList, controlConfig);
group.writeEntry("Meta", metaConfig);
group.writeEntry("Alt", altConfig);
group.writeEntry("Shift", shiftConfig);
group.writeEntry("Control", controlConfig);
group.sync();
workspace()->slotReconfigure();
// trigger once to verify the shortcut works
quint32 timestamp = 1;
QFETCH(int, modifier);
QVERIFY(!workspace()->globalShortcutsDisabled());
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 1);
triggeredSpy.clear();
// now disable global shortcuts
workspace()->disableGlobalShortcutsForClient(true);
QVERIFY(workspace()->globalShortcutsDisabled());
// Should not get triggered
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 0);
triggeredSpy.clear();
// enable again
workspace()->disableGlobalShortcutsForClient(false);
QVERIFY(!workspace()->globalShortcutsDisabled());
// should get triggered again
kwinApp()->platform()->keyboardKeyPressed(modifier, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifier, timestamp++);
QCOMPARE(triggeredSpy.count(), 1);
}
[autotest/integration] Add a test case for modifier only shortcuts This test verifies the functionality of modifier only shortcut activation. The base test case uses a helper object which is exported to DBus and has a slot which can get triggered. The test configures the individual modifiers to call that DBus method when the shortcut is triggered. It simulates pressing the modifier and verifies the DBus method was invoked or not.
2016-08-13 12:35:01 +00:00
WAYLANDTEST_MAIN(ModifierOnlyShortcutTest)
#include "modifier_only_shortcut_test.moc"
Reference in a new issue Copy permalink