1fb9f6f13a
The main advantage of SPDX license identifiers over the traditional license headers is that it's more difficult to overlook inappropriate licenses for kwin, for example GPL 3. We also don't have to copy a lot of boilerplate text. In order to create this change, I ran licensedigger -r -c from the toplevel source directory.
1055 lines
38 KiB
C++
1055 lines
38 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
*********************************************************************/
|
|
// kwin
|
|
#include "../atoms.h"
|
|
#include "../cursor.h"
|
|
#include "../input.h"
|
|
#include "../gestures.h"
|
|
#include "../main.h"
|
|
#include "../screenedge.h"
|
|
#include "../screens.h"
|
|
#include "../utils.h"
|
|
#include "../virtualdesktops.h"
|
|
#include "../xcbutils.h"
|
|
#include "mock_screens.h"
|
|
#include "mock_workspace.h"
|
|
#include "mock_x11client.h"
|
|
#include "testutils.h"
|
|
// Frameworks
|
|
#include <KConfigGroup>
|
|
// Qt
|
|
#include <QtTest>
|
|
#include <QX11Info>
|
|
// xcb
|
|
#include <xcb/xcb.h>
|
|
Q_DECLARE_METATYPE(KWin::ElectricBorder)
|
|
|
|
Q_LOGGING_CATEGORY(KWIN_CORE, "kwin_core")
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
Atoms* atoms;
|
|
int screen_number = 0;
|
|
|
|
InputRedirection *InputRedirection::s_self = nullptr;
|
|
|
|
void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action)
|
|
{
|
|
Q_UNUSED(shortcut)
|
|
Q_UNUSED(action)
|
|
}
|
|
|
|
void InputRedirection::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
|
|
{
|
|
Q_UNUSED(modifiers)
|
|
Q_UNUSED(axis)
|
|
Q_UNUSED(action)
|
|
}
|
|
|
|
void InputRedirection::registerTouchpadSwipeShortcut(SwipeDirection, QAction*)
|
|
{
|
|
}
|
|
|
|
void updateXTime()
|
|
{
|
|
}
|
|
|
|
class TestObject : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public Q_SLOTS:
|
|
bool callback(ElectricBorder border);
|
|
Q_SIGNALS:
|
|
void gotCallback(KWin::ElectricBorder);
|
|
};
|
|
|
|
bool TestObject::callback(KWin::ElectricBorder border)
|
|
{
|
|
emit gotCallback(border);
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
class TestScreenEdges : public QObject
|
|
{
|
|
Q_OBJECT
|
|
private Q_SLOTS:
|
|
void initTestCase();
|
|
void cleanupTestCase();
|
|
void init();
|
|
void cleanup();
|
|
void testInit();
|
|
void testCreatingInitialEdges();
|
|
void testCallback();
|
|
void testCallbackWithCheck();
|
|
void testPushBack_data();
|
|
void testPushBack();
|
|
void testFullScreenBlocking();
|
|
void testClientEdge();
|
|
void testTouchEdge();
|
|
void testTouchCallback_data();
|
|
void testTouchCallback();
|
|
};
|
|
|
|
void TestScreenEdges::initTestCase()
|
|
{
|
|
qApp->setProperty("x11RootWindow", QVariant::fromValue<quint32>(QX11Info::appRootWindow()));
|
|
qApp->setProperty("x11Connection", QVariant::fromValue<void*>(QX11Info::connection()));
|
|
KWin::atoms = new KWin::Atoms;
|
|
qRegisterMetaType<KWin::ElectricBorder>();
|
|
}
|
|
|
|
void TestScreenEdges::cleanupTestCase()
|
|
{
|
|
delete KWin::atoms;
|
|
}
|
|
|
|
void TestScreenEdges::init()
|
|
{
|
|
KWin::Cursors::self()->setMouse(new KWin::Cursor(this));
|
|
|
|
using namespace KWin;
|
|
new MockWorkspace;
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
Screens::create();
|
|
|
|
auto vd = VirtualDesktopManager::create();
|
|
vd->setConfig(config);
|
|
vd->load();
|
|
auto s = ScreenEdges::create();
|
|
s->setConfig(config);
|
|
}
|
|
|
|
void TestScreenEdges::cleanup()
|
|
{
|
|
using namespace KWin;
|
|
delete ScreenEdges::self();
|
|
delete VirtualDesktopManager::self();
|
|
delete Screens::self();
|
|
delete workspace();
|
|
}
|
|
|
|
void TestScreenEdges::testInit()
|
|
{
|
|
using namespace KWin;
|
|
auto s = ScreenEdges::self();
|
|
s->init();
|
|
QCOMPARE(s->isDesktopSwitching(), false);
|
|
QCOMPARE(s->isDesktopSwitchingMovingClients(), false);
|
|
QCOMPARE(s->timeThreshold(), 150);
|
|
QCOMPARE(s->reActivationThreshold(), 350);
|
|
QCOMPARE(s->cursorPushBackDistance(), QSize(1, 1));
|
|
QCOMPARE(s->actionTopLeft(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionTop(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionTopRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottomRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottom(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottomLeft(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionLeft(), ElectricBorderAction::ElectricActionNone);
|
|
|
|
QList<Edge*> edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 8);
|
|
for (auto e : edges) {
|
|
QVERIFY(!e->isReserved());
|
|
QVERIFY(e->inherits("KWin::WindowBasedEdge"));
|
|
QVERIFY(!e->inherits("KWin::AreaBasedEdge"));
|
|
QVERIFY(!e->client());
|
|
QVERIFY(!e->isApproaching());
|
|
}
|
|
Edge *te = edges.at(0);
|
|
QVERIFY(te->isCorner());
|
|
QVERIFY(!te->isScreenEdge());
|
|
QVERIFY(te->isLeft());
|
|
QVERIFY(te->isTop());
|
|
QVERIFY(!te->isRight());
|
|
QVERIFY(!te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricTopLeft);
|
|
te = edges.at(1);
|
|
QVERIFY(te->isCorner());
|
|
QVERIFY(!te->isScreenEdge());
|
|
QVERIFY(te->isLeft());
|
|
QVERIFY(!te->isTop());
|
|
QVERIFY(!te->isRight());
|
|
QVERIFY(te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricBottomLeft);
|
|
te = edges.at(2);
|
|
QVERIFY(!te->isCorner());
|
|
QVERIFY(te->isScreenEdge());
|
|
QVERIFY(te->isLeft());
|
|
QVERIFY(!te->isTop());
|
|
QVERIFY(!te->isRight());
|
|
QVERIFY(!te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricLeft);
|
|
te = edges.at(3);
|
|
QVERIFY(te->isCorner());
|
|
QVERIFY(!te->isScreenEdge());
|
|
QVERIFY(!te->isLeft());
|
|
QVERIFY(te->isTop());
|
|
QVERIFY(te->isRight());
|
|
QVERIFY(!te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricTopRight);
|
|
te = edges.at(4);
|
|
QVERIFY(te->isCorner());
|
|
QVERIFY(!te->isScreenEdge());
|
|
QVERIFY(!te->isLeft());
|
|
QVERIFY(!te->isTop());
|
|
QVERIFY(te->isRight());
|
|
QVERIFY(te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricBottomRight);
|
|
te = edges.at(5);
|
|
QVERIFY(!te->isCorner());
|
|
QVERIFY(te->isScreenEdge());
|
|
QVERIFY(!te->isLeft());
|
|
QVERIFY(!te->isTop());
|
|
QVERIFY(te->isRight());
|
|
QVERIFY(!te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricRight);
|
|
te = edges.at(6);
|
|
QVERIFY(!te->isCorner());
|
|
QVERIFY(te->isScreenEdge());
|
|
QVERIFY(!te->isLeft());
|
|
QVERIFY(te->isTop());
|
|
QVERIFY(!te->isRight());
|
|
QVERIFY(!te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricTop);
|
|
te = edges.at(7);
|
|
QVERIFY(!te->isCorner());
|
|
QVERIFY(te->isScreenEdge());
|
|
QVERIFY(!te->isLeft());
|
|
QVERIFY(!te->isTop());
|
|
QVERIFY(!te->isRight());
|
|
QVERIFY(te->isBottom());
|
|
QCOMPARE(te->border(), ElectricBorder::ElectricBottom);
|
|
|
|
// we shouldn't have any x windows, though
|
|
QCOMPARE(s->windows().size(), 0);
|
|
}
|
|
|
|
void TestScreenEdges::testCreatingInitialEdges()
|
|
{
|
|
using namespace KWin;
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
config->group("Windows").writeEntry("ElectricBorders", 2/*ElectricAlways*/);
|
|
config->sync();
|
|
|
|
auto s = ScreenEdges::self();
|
|
s->setConfig(config);
|
|
s->init();
|
|
// we don't have multiple desktops, so it's returning false
|
|
QCOMPARE(s->isDesktopSwitching(), true);
|
|
QCOMPARE(s->isDesktopSwitchingMovingClients(), true);
|
|
QCOMPARE(s->actionTopLeft(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionTop(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionTopRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottomRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottom(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottomLeft(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionLeft(), ElectricBorderAction::ElectricActionNone);
|
|
|
|
QEXPECT_FAIL("", "needs fixing", Continue);
|
|
QCOMPARE(s->windows().size(), 0);
|
|
|
|
// set some reasonable virtual desktops
|
|
config->group("Desktops").writeEntry("Number", 4);
|
|
config->sync();
|
|
auto vd = VirtualDesktopManager::self();
|
|
vd->setConfig(config);
|
|
vd->load();
|
|
vd->updateLayout();
|
|
QCOMPARE(vd->count(), 4u);
|
|
QCOMPARE(vd->grid().width(), 2);
|
|
QCOMPARE(vd->grid().height(), 2);
|
|
|
|
// approach windows for edges not created as screen too small
|
|
s->updateLayout();
|
|
auto edgeWindows = s->windows();
|
|
QCOMPARE(edgeWindows.size(), 12);
|
|
|
|
auto testWindowGeometry = [&](int index) {
|
|
Xcb::WindowGeometry geo(edgeWindows[index]);
|
|
return geo.rect();
|
|
};
|
|
QRect sg = screens()->geometry();
|
|
const int co = s->cornerOffset();
|
|
QList<QRect> expectedGeometries{
|
|
QRect(0, 0, 1, 1),
|
|
QRect(0, 0, co, co),
|
|
QRect(0, sg.bottom(), 1, 1),
|
|
QRect(0, sg.height() - co, co, co),
|
|
QRect(0, co, 1, sg.height() - co*2),
|
|
// QRect(0, co * 2 + 1, co, sg.height() - co*4),
|
|
QRect(sg.right(), 0, 1, 1),
|
|
QRect(sg.right() - co + 1, 0, co, co),
|
|
QRect(sg.right(), sg.bottom(), 1, 1),
|
|
QRect(sg.right() - co + 1, sg.bottom() - co + 1, co, co),
|
|
QRect(sg.right(), co, 1, sg.height() - co*2),
|
|
// QRect(sg.right() - co + 1, co * 2, co, sg.height() - co*4),
|
|
QRect(co, 0, sg.width() - co * 2, 1),
|
|
// QRect(co * 2, 0, sg.width() - co * 4, co),
|
|
QRect(co, sg.bottom(), sg.width() - co * 2, 1),
|
|
// QRect(co * 2, sg.height() - co, sg.width() - co * 4, co)
|
|
};
|
|
for (int i = 0; i < 12; ++i) {
|
|
QCOMPARE(testWindowGeometry(i), expectedGeometries.at(i));
|
|
}
|
|
QList<Edge*> edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 8);
|
|
for (auto e : edges) {
|
|
QVERIFY(e->isReserved());
|
|
QCOMPARE(e->activatesForPointer(), true);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
|
|
static_cast<MockScreens*>(screens())->setGeometries(QList<QRect>{QRect{0, 0, 1024, 768}});
|
|
QSignalSpy changedSpy(screens(), &Screens::changed);
|
|
QVERIFY(changedSpy.isValid());
|
|
// first is before it's updated
|
|
QVERIFY(changedSpy.wait());
|
|
// second is after it's updated
|
|
QVERIFY(changedSpy.wait());
|
|
|
|
// let's update the layout and verify that we have edges
|
|
s->recreateEdges();
|
|
edgeWindows = s->windows();
|
|
QCOMPARE(edgeWindows.size(), 16);
|
|
sg = screens()->geometry();
|
|
expectedGeometries = QList<QRect>{
|
|
QRect(0, 0, 1, 1),
|
|
QRect(0, 0, co, co),
|
|
QRect(0, sg.bottom(), 1, 1),
|
|
QRect(0, sg.height() - co, co, co),
|
|
QRect(0, co, 1, sg.height() - co*2),
|
|
QRect(0, co * 2 + 1, co, sg.height() - co*4),
|
|
QRect(sg.right(), 0, 1, 1),
|
|
QRect(sg.right() - co + 1, 0, co, co),
|
|
QRect(sg.right(), sg.bottom(), 1, 1),
|
|
QRect(sg.right() - co + 1, sg.bottom() - co + 1, co, co),
|
|
QRect(sg.right(), co, 1, sg.height() - co*2),
|
|
QRect(sg.right() - co + 1, co * 2, co, sg.height() - co*4),
|
|
QRect(co, 0, sg.width() - co * 2, 1),
|
|
QRect(co * 2, 0, sg.width() - co * 4, co),
|
|
QRect(co, sg.bottom(), sg.width() - co * 2, 1),
|
|
QRect(co * 2, sg.height() - co, sg.width() - co * 4, co)
|
|
};
|
|
for (int i = 0; i < 16; ++i) {
|
|
QCOMPARE(testWindowGeometry(i), expectedGeometries.at(i));
|
|
}
|
|
|
|
// disable desktop switching again
|
|
config->group("Windows").writeEntry("ElectricBorders", 1/*ElectricMoveOnly*/);
|
|
s->reconfigure();
|
|
QCOMPARE(s->isDesktopSwitching(), false);
|
|
QCOMPARE(s->isDesktopSwitchingMovingClients(), true);
|
|
QCOMPARE(s->windows().size(), 0);
|
|
edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 8);
|
|
for (int i = 0; i < 8; ++i) {
|
|
auto e = edges.at(i);
|
|
QVERIFY(!e->isReserved());
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
QCOMPARE(e->approachGeometry(), expectedGeometries.at(i*2+1));
|
|
}
|
|
|
|
// let's start a move of window.
|
|
X11Client client(workspace());
|
|
workspace()->setMoveResizeClient(&client);
|
|
for (int i = 0; i < 8; ++i) {
|
|
auto e = edges.at(i);
|
|
QVERIFY(!e->isReserved());
|
|
QCOMPARE(e->activatesForPointer(), true);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
QCOMPARE(e->approachGeometry(), expectedGeometries.at(i*2+1));
|
|
}
|
|
// not for resize
|
|
client.setResize(true);
|
|
for (int i = 0; i < 8; ++i) {
|
|
auto e = edges.at(i);
|
|
QVERIFY(!e->isReserved());
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
QCOMPARE(e->approachGeometry(), expectedGeometries.at(i*2+1));
|
|
}
|
|
workspace()->setMoveResizeClient(nullptr);
|
|
}
|
|
|
|
void TestScreenEdges::testCallback()
|
|
{
|
|
using namespace KWin;
|
|
MockWorkspace ws;
|
|
static_cast<MockScreens*>(screens())->setGeometries(QList<QRect>{QRect{0, 0, 1024, 768}, QRect{200, 768, 1024, 768}});
|
|
QSignalSpy changedSpy(screens(), &Screens::changed);
|
|
QVERIFY(changedSpy.isValid());
|
|
// first is before it's updated
|
|
QVERIFY(changedSpy.wait());
|
|
// second is after it's updated
|
|
QVERIFY(changedSpy.wait());
|
|
auto s = ScreenEdges::self();
|
|
s->init();
|
|
TestObject callback;
|
|
QSignalSpy spy(&callback, &TestObject::gotCallback);
|
|
QVERIFY(spy.isValid());
|
|
s->reserve(ElectricLeft, &callback, "callback");
|
|
s->reserve(ElectricTopLeft, &callback, "callback");
|
|
s->reserve(ElectricTop, &callback, "callback");
|
|
s->reserve(ElectricTopRight, &callback, "callback");
|
|
s->reserve(ElectricRight, &callback, "callback");
|
|
s->reserve(ElectricBottomRight, &callback, "callback");
|
|
s->reserve(ElectricBottom, &callback, "callback");
|
|
s->reserve(ElectricBottomLeft, &callback, "callback");
|
|
|
|
QList<Edge*> edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 10);
|
|
for (auto e: edges) {
|
|
QVERIFY(e->isReserved());
|
|
QCOMPARE(e->activatesForPointer(), true);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
auto it = std::find_if(edges.constBegin(), edges.constEnd(), [](Edge *e) {
|
|
return e->isScreenEdge() && e->isLeft() && e->approachGeometry().bottom() < 768;
|
|
});
|
|
QVERIFY(it != edges.constEnd());
|
|
|
|
xcb_enter_notify_event_t event;
|
|
auto setPos = [&event] (const QPoint &pos) {
|
|
Cursors::self()->mouse()->setPos(pos);
|
|
event.root_x = pos.x();
|
|
event.root_y = pos.y();
|
|
event.event_x = pos.x();
|
|
event.event_y = pos.y();
|
|
};
|
|
event.root = XCB_WINDOW_NONE;
|
|
event.child = XCB_WINDOW_NONE;
|
|
event.event = (*it)->window();
|
|
event.same_screen_focus = 1;
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
setPos(QPoint(0, 50));
|
|
auto isEntered = [s] (xcb_enter_notify_event_t *event) {
|
|
return s->handleEnterNotifiy(event->event, QPoint(event->root_x, event->root_y), QDateTime::fromMSecsSinceEpoch(event->time, Qt::UTC));
|
|
};
|
|
QVERIFY(isEntered(&event));
|
|
// doesn't trigger as the edge was not triggered yet
|
|
QVERIFY(spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 50));
|
|
|
|
// test doesn't trigger due to too much offset
|
|
QTest::qWait(160);
|
|
setPos(QPoint(0, 100));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 100));
|
|
|
|
// doesn't trigger as we are waiting too long already
|
|
QTest::qWait(200);
|
|
setPos(QPoint(0, 101));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 101));
|
|
|
|
// doesn't activate as we are waiting too short
|
|
QTest::qWait(50);
|
|
setPos(QPoint(0, 100));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 100));
|
|
|
|
// and this one triggers
|
|
QTest::qWait(110);
|
|
setPos(QPoint(0, 101));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(!spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 101));
|
|
|
|
// now let's try to trigger again
|
|
QTest::qWait(351);
|
|
setPos(QPoint(0, 100));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 100));
|
|
// it's still under the reactivation
|
|
QTest::qWait(50);
|
|
setPos(QPoint(0, 100));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 100));
|
|
// now it should trigger again
|
|
QTest::qWait(250);
|
|
setPos(QPoint(0, 100));
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QCOMPARE(spy.count(), 2);
|
|
QCOMPARE(spy.first().first().value<ElectricBorder>(), ElectricLeft);
|
|
QCOMPARE(spy.last().first().value<ElectricBorder>(), ElectricLeft);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 100));
|
|
|
|
// let's disable pushback
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
config->group("Windows").writeEntry("ElectricBorderPushbackPixels", 0);
|
|
config->sync();
|
|
s->setConfig(config);
|
|
s->reconfigure();
|
|
// it should trigger directly
|
|
QTest::qWait(350);
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QCOMPARE(spy.count(), 3);
|
|
QCOMPARE(spy.at(0).first().value<ElectricBorder>(), ElectricLeft);
|
|
QCOMPARE(spy.at(1).first().value<ElectricBorder>(), ElectricLeft);
|
|
QCOMPARE(spy.at(2).first().value<ElectricBorder>(), ElectricLeft);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(0, 100));
|
|
|
|
// now let's unreserve again
|
|
s->unreserve(ElectricTopLeft, &callback);
|
|
s->unreserve(ElectricTop, &callback);
|
|
s->unreserve(ElectricTopRight, &callback);
|
|
s->unreserve(ElectricRight, &callback);
|
|
s->unreserve(ElectricBottomRight, &callback);
|
|
s->unreserve(ElectricBottom, &callback);
|
|
s->unreserve(ElectricBottomLeft, &callback);
|
|
s->unreserve(ElectricLeft, &callback);
|
|
for (auto e: s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly)) {
|
|
QVERIFY(!e->isReserved());
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
}
|
|
|
|
void TestScreenEdges::testCallbackWithCheck()
|
|
{
|
|
using namespace KWin;
|
|
auto s = ScreenEdges::self();
|
|
s->init();
|
|
TestObject callback;
|
|
QSignalSpy spy(&callback, &TestObject::gotCallback);
|
|
QVERIFY(spy.isValid());
|
|
s->reserve(ElectricLeft, &callback, "callback");
|
|
|
|
// check activating a different edge doesn't do anything
|
|
s->check(QPoint(50, 0), QDateTime::currentDateTimeUtc(), true);
|
|
QVERIFY(spy.isEmpty());
|
|
|
|
// try a direct activate without pushback
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
s->check(QPoint(0, 50), QDateTime::currentDateTimeUtc(), true);
|
|
QCOMPARE(spy.count(), 1);
|
|
QEXPECT_FAIL("", "Argument says force no pushback, but it gets pushed back. Needs investigation", Continue);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(0, 50));
|
|
|
|
// use a different edge, this time with pushback
|
|
s->reserve(KWin::ElectricRight, &callback, "callback");
|
|
Cursors::self()->mouse()->setPos(99, 50);
|
|
s->check(QPoint(99, 50), QDateTime::currentDateTimeUtc());
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(spy.last().first().value<ElectricBorder>(), ElectricLeft);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(98, 50));
|
|
// and trigger it again
|
|
QTest::qWait(160);
|
|
Cursors::self()->mouse()->setPos(99, 50);
|
|
s->check(QPoint(99, 50), QDateTime::currentDateTimeUtc());
|
|
QCOMPARE(spy.count(), 2);
|
|
QCOMPARE(spy.last().first().value<ElectricBorder>(), ElectricRight);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(98, 50));
|
|
}
|
|
|
|
void TestScreenEdges::testPushBack_data()
|
|
{
|
|
QTest::addColumn<KWin::ElectricBorder>("border");
|
|
QTest::addColumn<int>("pushback");
|
|
QTest::addColumn<QPoint>("trigger");
|
|
QTest::addColumn<QPoint>("expected");
|
|
|
|
QTest::newRow("topleft-3") << KWin::ElectricTopLeft << 3 << QPoint(0, 0) << QPoint(3, 3);
|
|
QTest::newRow("top-5") << KWin::ElectricTop << 5 << QPoint(50, 0) << QPoint(50, 5);
|
|
QTest::newRow("toprigth-2") << KWin::ElectricTopRight << 2 << QPoint(99, 0) << QPoint(97, 2);
|
|
QTest::newRow("right-10") << KWin::ElectricRight << 10 << QPoint(99, 50) << QPoint(89, 50);
|
|
QTest::newRow("bottomright-5") << KWin::ElectricBottomRight << 5 << QPoint(99, 99) << QPoint(94, 94);
|
|
QTest::newRow("bottom-10") << KWin::ElectricBottom << 10 << QPoint(50, 99) << QPoint(50, 89);
|
|
QTest::newRow("bottomleft-3") << KWin::ElectricBottomLeft << 3 << QPoint(0, 99) << QPoint(3, 96);
|
|
QTest::newRow("left-10") << KWin::ElectricLeft << 10 << QPoint(0, 50) << QPoint(10, 50);
|
|
QTest::newRow("invalid") << KWin::ElectricLeft << 10 << QPoint(50, 0) << QPoint(50, 0);
|
|
}
|
|
|
|
void TestScreenEdges::testPushBack()
|
|
{
|
|
using namespace KWin;
|
|
QFETCH(int, pushback);
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
config->group("Windows").writeEntry("ElectricBorderPushbackPixels", pushback);
|
|
config->sync();
|
|
|
|
// TODO: add screens
|
|
|
|
auto s = ScreenEdges::self();
|
|
s->setConfig(config);
|
|
s->init();
|
|
TestObject callback;
|
|
QSignalSpy spy(&callback, &TestObject::gotCallback);
|
|
QVERIFY(spy.isValid());
|
|
QFETCH(ElectricBorder, border);
|
|
s->reserve(border, &callback, "callback");
|
|
|
|
QFETCH(QPoint, trigger);
|
|
Cursors::self()->mouse()->setPos(trigger);
|
|
xcb_enter_notify_event_t event;
|
|
event.root_x = trigger.x();
|
|
event.root_y = trigger.y();
|
|
event.event_x = trigger.x();
|
|
event.event_y = trigger.y();
|
|
event.root = XCB_WINDOW_NONE;
|
|
event.child = XCB_WINDOW_NONE;
|
|
event.event = s->windows().first();
|
|
event.same_screen_focus = 1;
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
auto isEntered = [s] (xcb_enter_notify_event_t *event) {
|
|
return s->handleEnterNotifiy(event->event, QPoint(event->root_x, event->root_y), QDateTime::fromMSecsSinceEpoch(event->time));
|
|
};
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
QTEST(Cursors::self()->mouse()->pos(), "expected");
|
|
|
|
// do the same without the event, but the check method
|
|
Cursors::self()->mouse()->setPos(trigger);
|
|
s->check(trigger, QDateTime::currentDateTimeUtc());
|
|
QVERIFY(spy.isEmpty());
|
|
QTEST(Cursors::self()->mouse()->pos(), "expected");
|
|
}
|
|
|
|
void TestScreenEdges::testFullScreenBlocking()
|
|
{
|
|
using namespace KWin;
|
|
MockWorkspace ws;
|
|
X11Client client(&ws);
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
config->group("Windows").writeEntry("ElectricBorderPushbackPixels", 1);
|
|
config->sync();
|
|
|
|
auto s = ScreenEdges::self();
|
|
s->setConfig(config);
|
|
s->init();
|
|
TestObject callback;
|
|
QSignalSpy spy(&callback, &TestObject::gotCallback);
|
|
QVERIFY(spy.isValid());
|
|
s->reserve(KWin::ElectricLeft, &callback, "callback");
|
|
s->reserve(KWin::ElectricBottomRight, &callback, "callback");
|
|
QAction action;
|
|
s->reserveTouch(KWin::ElectricRight, &action);
|
|
// currently there is no active client yet, so check blocking shouldn't do anything
|
|
emit s->checkBlocking();
|
|
for (auto e: s->findChildren<Edge*>()) {
|
|
QCOMPARE(e->activatesForTouchGesture(), e->border() == KWin::ElectricRight);
|
|
}
|
|
|
|
xcb_enter_notify_event_t event;
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
event.root_x = 0;
|
|
event.root_y = 50;
|
|
event.event_x = 0;
|
|
event.event_y = 50;
|
|
event.root = XCB_WINDOW_NONE;
|
|
event.child = XCB_WINDOW_NONE;
|
|
event.event = s->windows().first();
|
|
event.same_screen_focus = 1;
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
auto isEntered = [s] (xcb_enter_notify_event_t *event) {
|
|
return s->handleEnterNotifiy(event->event, QPoint(event->root_x, event->root_y), QDateTime::fromMSecsSinceEpoch(event->time));
|
|
};
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 50));
|
|
|
|
client.setFrameGeometry(screens()->geometry());
|
|
client.setActive(true);
|
|
client.setFullScreen(true);
|
|
ws.setActiveClient(&client);
|
|
emit s->checkBlocking();
|
|
// the signal doesn't trigger for corners, let's go over all windows just to be sure that it doesn't call for corners
|
|
for (auto e: s->findChildren<Edge*>()) {
|
|
e->checkBlocking();
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
// calling again should not trigger
|
|
QTest::qWait(160);
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
// and no pushback
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(0, 50));
|
|
|
|
// let's make the client not fullscreen, which should trigger
|
|
client.setFullScreen(false);
|
|
emit s->checkBlocking();
|
|
for (auto e: s->findChildren<Edge*>()) {
|
|
QCOMPARE(e->activatesForTouchGesture(), e->border() == KWin::ElectricRight);
|
|
}
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(!spy.isEmpty());
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 50));
|
|
|
|
// let's make the client fullscreen again, but with a geometry not intersecting the left edge
|
|
QTest::qWait(351);
|
|
client.setFullScreen(true);
|
|
client.setFrameGeometry(client.frameGeometry().translated(10, 0));
|
|
emit s->checkBlocking();
|
|
spy.clear();
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
// and a pushback
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 50));
|
|
|
|
// just to be sure, let's set geometry back
|
|
client.setFrameGeometry(screens()->geometry());
|
|
emit s->checkBlocking();
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
// and no pushback
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(0, 50));
|
|
|
|
// the corner should always trigger
|
|
s->unreserve(KWin::ElectricLeft, &callback);
|
|
event.event_x = 99;
|
|
event.event_y = 99;
|
|
event.root_x = 99;
|
|
event.root_y = 99;
|
|
event.event = s->windows().first();
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
Cursors::self()->mouse()->setPos(99, 99);
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(spy.isEmpty());
|
|
// and pushback
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(98, 98));
|
|
QTest::qWait(160);
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
Cursors::self()->mouse()->setPos(99, 99);
|
|
QVERIFY(isEntered(&event));
|
|
QVERIFY(!spy.isEmpty());
|
|
}
|
|
|
|
void TestScreenEdges::testClientEdge()
|
|
{
|
|
using namespace KWin;
|
|
X11Client client(workspace());
|
|
client.setFrameGeometry(QRect(10, 50, 10, 50));
|
|
auto s = ScreenEdges::self();
|
|
s->init();
|
|
|
|
s->reserve(&client, KWin::ElectricBottom);
|
|
|
|
QPointer<Edge> edge = s->findChildren<Edge*>().last();
|
|
|
|
QCOMPARE(edge->isReserved(), true);
|
|
QCOMPARE(edge->activatesForPointer(), true);
|
|
QCOMPARE(edge->activatesForTouchGesture(), true);
|
|
|
|
//remove old reserves and resize to be in the middle of the screen
|
|
s->reserve(&client, KWin::ElectricNone);
|
|
client.setFrameGeometry(QRect(2, 2, 20, 20));
|
|
|
|
// for none of the edges it should be able to be set
|
|
for (int i = 0; i < ELECTRIC_COUNT; ++i) {
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, static_cast<ElectricBorder>(i));
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
}
|
|
|
|
// now let's try to set it and activate it
|
|
client.setFrameGeometry(screens()->geometry());
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, KWin::ElectricLeft);
|
|
QCOMPARE(client.isHiddenInternal(), true);
|
|
|
|
xcb_enter_notify_event_t event;
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
event.root_x = 0;
|
|
event.root_y = 50;
|
|
event.event_x = 0;
|
|
event.event_y = 50;
|
|
event.root = XCB_WINDOW_NONE;
|
|
event.child = XCB_WINDOW_NONE;
|
|
event.event = s->windows().first();
|
|
event.same_screen_focus = 1;
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
auto isEntered = [s] (xcb_enter_notify_event_t *event) {
|
|
return s->handleEnterNotifiy(event->event, QPoint(event->root_x, event->root_y), QDateTime::fromMSecsSinceEpoch(event->time));
|
|
};
|
|
QVERIFY(isEntered(&event));
|
|
// autohiding panels shall activate instantly
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 50));
|
|
|
|
// now let's reserve the client for each of the edges, in the end for the right one
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, KWin::ElectricTop);
|
|
s->reserve(&client, KWin::ElectricBottom);
|
|
QCOMPARE(client.isHiddenInternal(), true);
|
|
// corners shouldn't get reserved
|
|
s->reserve(&client, KWin::ElectricTopLeft);
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, KWin::ElectricTopRight);
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, KWin::ElectricBottomRight);
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, KWin::ElectricBottomLeft);
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
// now finally reserve on right one
|
|
client.setHiddenInternal(true);
|
|
s->reserve(&client, KWin::ElectricRight);
|
|
QCOMPARE(client.isHiddenInternal(), true);
|
|
|
|
// now let's emulate the removal of a Client through Workspace
|
|
emit workspace()->clientRemoved(&client);
|
|
for (auto e : s->findChildren<Edge*>()) {
|
|
QVERIFY(!e->client());
|
|
}
|
|
QCOMPARE(client.isHiddenInternal(), true);
|
|
|
|
// now let's try to trigger the client showing with the check method instead of enter notify
|
|
s->reserve(&client, KWin::ElectricTop);
|
|
QCOMPARE(client.isHiddenInternal(), true);
|
|
Cursors::self()->mouse()->setPos(50, 0);
|
|
s->check(QPoint(50, 0), QDateTime::currentDateTimeUtc());
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(50, 1));
|
|
|
|
// unreserve by setting to none edge
|
|
s->reserve(&client, KWin::ElectricNone);
|
|
// check on previous edge again, should fail
|
|
client.setHiddenInternal(true);
|
|
Cursors::self()->mouse()->setPos(50, 0);
|
|
s->check(QPoint(50, 0), QDateTime::currentDateTimeUtc());
|
|
QCOMPARE(client.isHiddenInternal(), true);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(50, 0));
|
|
|
|
// set to windows can cover
|
|
client.setFrameGeometry(screens()->geometry());
|
|
client.setHiddenInternal(false);
|
|
client.setKeepBelow(true);
|
|
s->reserve(&client, KWin::ElectricLeft);
|
|
QCOMPARE(client.keepBelow(), true);
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
|
|
xcb_enter_notify_event_t event2;
|
|
Cursors::self()->mouse()->setPos(0, 50);
|
|
event2.root_x = 0;
|
|
event2.root_y = 50;
|
|
event2.event_x = 0;
|
|
event2.event_y = 50;
|
|
event2.root = XCB_WINDOW_NONE;
|
|
event2.child = XCB_WINDOW_NONE;
|
|
event2.event = s->windows().first();
|
|
event2.same_screen_focus = 1;
|
|
event2.time = QDateTime::currentMSecsSinceEpoch();
|
|
QVERIFY(isEntered(&event2));
|
|
QCOMPARE(client.keepBelow(), false);
|
|
QCOMPARE(client.isHiddenInternal(), false);
|
|
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 50));
|
|
}
|
|
|
|
void TestScreenEdges::testTouchEdge()
|
|
{
|
|
qRegisterMetaType<KWin::ElectricBorder>("ElectricBorder");
|
|
using namespace KWin;
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
auto group = config->group("TouchEdges");
|
|
group.writeEntry("Top", "krunner");
|
|
group.writeEntry("Left", "krunner");
|
|
group.writeEntry("Bottom", "krunner");
|
|
group.writeEntry("Right", "krunner");
|
|
config->sync();
|
|
|
|
auto s = ScreenEdges::self();
|
|
s->setConfig(config);
|
|
s->init();
|
|
// we don't have multiple desktops, so it's returning false
|
|
QCOMPARE(s->isDesktopSwitching(), false);
|
|
QCOMPARE(s->isDesktopSwitchingMovingClients(), false);
|
|
QCOMPARE(s->actionTopLeft(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionTop(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionTopRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottomRight(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottom(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionBottomLeft(), ElectricBorderAction::ElectricActionNone);
|
|
QCOMPARE(s->actionLeft(), ElectricBorderAction::ElectricActionNone);
|
|
|
|
QList<Edge*> edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 8);
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), e->isScreenEdge());
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), e->isScreenEdge());
|
|
}
|
|
|
|
// try to activate the edge through pointer, should not be possible
|
|
auto it = std::find_if(edges.constBegin(), edges.constEnd(), [](Edge *e) {
|
|
return e->isScreenEdge() && e->isLeft();
|
|
});
|
|
QVERIFY(it != edges.constEnd());
|
|
|
|
QSignalSpy approachingSpy(s, &ScreenEdges::approaching);
|
|
QVERIFY(approachingSpy.isValid());
|
|
|
|
xcb_enter_notify_event_t event;
|
|
auto setPos = [&event] (const QPoint &pos) {
|
|
Cursors::self()->mouse()->setPos(pos);
|
|
event.root_x = pos.x();
|
|
event.root_y = pos.y();
|
|
event.event_x = pos.x();
|
|
event.event_y = pos.y();
|
|
};
|
|
event.root = XCB_WINDOW_NONE;
|
|
event.child = XCB_WINDOW_NONE;
|
|
event.event = (*it)->window();
|
|
event.same_screen_focus = 1;
|
|
event.time = QDateTime::currentMSecsSinceEpoch();
|
|
setPos(QPoint(0, 50));
|
|
auto isEntered = [s] (xcb_enter_notify_event_t *event) {
|
|
return s->handleEnterNotifiy(event->event, QPoint(event->root_x, event->root_y), QDateTime::fromMSecsSinceEpoch(event->time, Qt::UTC));
|
|
};
|
|
QCOMPARE(isEntered(&event), false);
|
|
QVERIFY(approachingSpy.isEmpty());
|
|
// let's also verify the check
|
|
s->check(QPoint(0, 50), QDateTime::currentDateTimeUtc(), false);
|
|
QVERIFY(approachingSpy.isEmpty());
|
|
|
|
s->gestureRecognizer()->startSwipeGesture(QPoint(0, 50));
|
|
QCOMPARE(approachingSpy.count(), 1);
|
|
s->gestureRecognizer()->cancelSwipeGesture();
|
|
QCOMPARE(approachingSpy.count(), 2);
|
|
|
|
// let's reconfigure
|
|
group.writeEntry("Top", "none");
|
|
group.writeEntry("Left", "none");
|
|
group.writeEntry("Bottom", "none");
|
|
group.writeEntry("Right", "none");
|
|
config->sync();
|
|
s->reconfigure();
|
|
|
|
edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 8);
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), false);
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
|
|
}
|
|
|
|
void TestScreenEdges::testTouchCallback_data()
|
|
{
|
|
QTest::addColumn<KWin::ElectricBorder>("border");
|
|
QTest::addColumn<QPoint>("startPos");
|
|
QTest::addColumn<QSizeF>("delta");
|
|
|
|
QTest::newRow("left") << KWin::ElectricLeft << QPoint(0, 50) << QSizeF(250, 20);
|
|
QTest::newRow("top") << KWin::ElectricTop << QPoint(50, 0) << QSizeF(20, 250);
|
|
QTest::newRow("right") << KWin::ElectricRight << QPoint(99, 50) << QSizeF(-200, 0);
|
|
QTest::newRow("bottom") << KWin::ElectricBottom << QPoint(50, 99) << QSizeF(0, -200);
|
|
}
|
|
|
|
void TestScreenEdges::testTouchCallback()
|
|
{
|
|
qRegisterMetaType<KWin::ElectricBorder>("ElectricBorder");
|
|
using namespace KWin;
|
|
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
|
auto group = config->group("TouchEdges");
|
|
group.writeEntry("Top", "none");
|
|
group.writeEntry("Left", "none");
|
|
group.writeEntry("Bottom", "none");
|
|
group.writeEntry("Right", "none");
|
|
config->sync();
|
|
|
|
auto s = ScreenEdges::self();
|
|
s->setConfig(config);
|
|
s->init();
|
|
|
|
// none of our actions should be reserved
|
|
const QList<Edge*> edges = s->findChildren<Edge*>(QString(), Qt::FindDirectChildrenOnly);
|
|
QCOMPARE(edges.size(), 8);
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), false);
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
|
|
// let's reserve an action
|
|
QAction action;
|
|
QSignalSpy actionTriggeredSpy(&action, &QAction::triggered);
|
|
QVERIFY(actionTriggeredSpy.isValid());
|
|
QSignalSpy approachingSpy(s, &ScreenEdges::approaching);
|
|
QVERIFY(approachingSpy.isValid());
|
|
|
|
// reserve on edge
|
|
QFETCH(KWin::ElectricBorder, border);
|
|
s->reserveTouch(border, &action);
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), e->border() == border);
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), e->border() == border);
|
|
}
|
|
|
|
QVERIFY(approachingSpy.isEmpty());
|
|
QFETCH(QPoint, startPos);
|
|
QCOMPARE(s->gestureRecognizer()->startSwipeGesture(startPos), 1);
|
|
QVERIFY(actionTriggeredSpy.isEmpty());
|
|
QCOMPARE(approachingSpy.count(), 1);
|
|
QFETCH(QSizeF, delta);
|
|
s->gestureRecognizer()->updateSwipeGesture(delta);
|
|
QCOMPARE(approachingSpy.count(), 2);
|
|
QVERIFY(actionTriggeredSpy.isEmpty());
|
|
s->gestureRecognizer()->endSwipeGesture();
|
|
QVERIFY(actionTriggeredSpy.wait());
|
|
QCOMPARE(actionTriggeredSpy.count(), 1);
|
|
QCOMPARE(approachingSpy.count(), 3);
|
|
|
|
// unreserve again
|
|
s->unreserveTouch(border, &action);
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), false);
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
|
|
// reserve another action
|
|
QScopedPointer<QAction> action2(new QAction);
|
|
s->reserveTouch(border, action2.data());
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), e->border() == border);
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), e->border() == border);
|
|
}
|
|
// and unreserve by destroying
|
|
action2.reset();
|
|
for (auto e : edges) {
|
|
QCOMPARE(e->isReserved(), false);
|
|
QCOMPARE(e->activatesForPointer(), false);
|
|
QCOMPARE(e->activatesForTouchGesture(), false);
|
|
}
|
|
}
|
|
|
|
Q_CONSTRUCTOR_FUNCTION(forceXcb)
|
|
QTEST_MAIN(TestScreenEdges)
|
|
#include "test_screen_edges.moc"
|