yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

waylandServer()->backend() replaced by kwinApp()->platform()

Browse source
This commit is contained in:
Martin Gräßlin 2016-04-07 08:28:35 +02:00
parent 58b59d3e20
commit 146af48f22
25 changed files with 145 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
autotests/wayland/debug_console_test.cpp
View file

@ -60,8 +60,8 @@ void DebugConsoleTest::initTestCase()
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();

16
autotests/wayland/decoration_input_test.cpp
View file

@ -74,13 +74,13 @@ private:
};
#define MOTION(target) \
waylandServer()->backend()->pointerMotion(target, timestamp++)
kwinApp()->platform()->pointerMotion(target, timestamp++)
#define PRESS \
waylandServer()->backend()->pointerButtonPressed(BTN_LEFT, timestamp++)
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++)
#define RELEASE \
waylandServer()->backend()->pointerButtonReleased(BTN_LEFT, timestamp++)
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++)
AbstractClient *DecorationInputTest::showWindow()
{
@ -130,8 +130,8 @@ void DecorationInputTest::initTestCase()
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
// change some options
@ -254,13 +254,13 @@ void DecorationInputTest::testAxis()
// TODO: mouse wheel direction looks wrong to me
// simulate wheel
waylandServer()->backend()->pointerAxisVertical(5.0, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
QVERIFY(c->keepBelow());
QVERIFY(!c->keepAbove());
waylandServer()->backend()->pointerAxisVertical(-5.0, timestamp++);
kwinApp()->platform()->pointerAxisVertical(-5.0, timestamp++);
QVERIFY(!c->keepBelow());
QVERIFY(!c->keepAbove());
waylandServer()->backend()->pointerAxisVertical(-5.0, timestamp++);
kwinApp()->platform()->pointerAxisVertical(-5.0, timestamp++);
QVERIFY(!c->keepBelow());
QVERIFY(c->keepAbove());
}

2
autotests/wayland/dont_crash_cancel_animation.cpp
View file

@ -71,7 +71,7 @@ void DontCrashCancelAnimationFromAnimationEndedTest::initTestCase()
qRegisterMetaType<KWin::Deleted*>();
qRegisterMetaType<KWin::ShellClient*>();
qRegisterMetaType<KWin::AbstractClient*>();
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
QVERIFY(Compositor::self());

2
autotests/wayland/dont_crash_glxgears.cpp
View file

@ -46,7 +46,7 @@ void DontCrashGlxgearsTest::initTestCase()
qRegisterMetaType<KWin::Deleted*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());

6
autotests/wayland/input_stacking_order.cpp
View file

@ -73,8 +73,8 @@ void InputStackingOrderTest::initTestCase()
qRegisterMetaType<KWin::Deleted*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
@ -220,7 +220,7 @@ void InputStackingOrderTest::testPointerFocusUpdatesOnStackingOrderChange()
QCOMPARE(window1->geometry(), window2->geometry());
// enter
waylandServer()->backend()->pointerMotion(QPointF(25, 25), 1);
kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
// window 2 should have focus

28
autotests/wayland/internal_window.cpp
View file

@ -142,8 +142,8 @@ void InternalWindowTest::initTestCase()
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
@ -182,14 +182,14 @@ void InternalWindowTest::testEnterLeave()
QVERIFY(moveSpy.isValid());
quint32 timestamp = 1;
waylandServer()->backend()->pointerMotion(QPoint(50, 50), timestamp++);
kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
QTRY_COMPARE(enterSpy.count(), 1);
waylandServer()->backend()->pointerMotion(QPoint(60, 50), timestamp++);
kwinApp()->platform()->pointerMotion(QPoint(60, 50), timestamp++);
QTRY_COMPARE(moveSpy.count(), 1);
QCOMPARE(moveSpy.first().first().toPoint(), QPoint(60, 50));
waylandServer()->backend()->pointerMotion(QPoint(101, 50), timestamp++);
kwinApp()->platform()->pointerMotion(QPoint(101, 50), timestamp++);
QTRY_COMPARE(leaveSpy.count(), 1);
}
@ -209,11 +209,11 @@ void InternalWindowTest::testPointerPressRelease()
QCOMPARE(clientAddedSpy.count(), 1);
quint32 timestamp = 1;
waylandServer()->backend()->pointerMotion(QPoint(50, 50), timestamp++);
kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
waylandServer()->backend()->pointerButtonPressed(BTN_LEFT, timestamp++);
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
QTRY_COMPARE(pressSpy.count(), 1);
waylandServer()->backend()->pointerButtonReleased(BTN_LEFT, timestamp++);
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
QTRY_COMPARE(releaseSpy.count(), 1);
}
@ -230,11 +230,11 @@ void InternalWindowTest::testPointerAxis()
QCOMPARE(clientAddedSpy.count(), 1);
quint32 timestamp = 1;
waylandServer()->backend()->pointerMotion(QPoint(50, 50), timestamp++);
kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
waylandServer()->backend()->pointerAxisVertical(5.0, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
QTRY_COMPARE(wheelSpy.count(), 1);
waylandServer()->backend()->pointerAxisHorizontal(5.0, timestamp++);
kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
QTRY_COMPARE(wheelSpy.count(), 2);
}
@ -262,12 +262,12 @@ void InternalWindowTest::testKeyboard()
quint32 timestamp = 1;
QFETCH(QPoint, cursorPos);
waylandServer()->backend()->pointerMotion(cursorPos, timestamp++);
kwinApp()->platform()->pointerMotion(cursorPos, timestamp++);
waylandServer()->backend()->keyboardKeyPressed(KEY_A, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
QTRY_COMPARE(pressSpy.count(), 1);
QCOMPARE(releaseSpy.count(), 0);
waylandServer()->backend()->keyboardKeyReleased(KEY_A, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
QTRY_COMPARE(releaseSpy.count(), 1);
QCOMPARE(pressSpy.count(), 1);
}

6
autotests/wayland/kwin_wayland_test.cpp
View file

@ -55,7 +55,7 @@ WaylandTestApplication::WaylandTestApplication(int &argc, char **argv)
WaylandTestApplication::~WaylandTestApplication()
{
waylandServer()->backend()->setOutputsEnabled(false);
kwinApp()->platform()->setOutputsEnabled(false);
destroyWorkspace();
waylandServer()->dispatch();
// need to unload all effects prior to destroying X connection as they might do X calls
@ -94,7 +94,7 @@ void WaylandTestApplication::performStartup()
void WaylandTestApplication::createBackend()
{
AbstractBackend *backend = waylandServer()->backend();
AbstractBackend *backend = kwinApp()->platform();
connect(backend, &AbstractBackend::screensQueried, this, &WaylandTestApplication::continueStartupWithScreens);
connect(backend, &AbstractBackend::initFailed, this,
[] () {
@ -107,7 +107,7 @@ void WaylandTestApplication::createBackend()
void WaylandTestApplication::continueStartupWithScreens()
{
disconnect(waylandServer()->backend(), &AbstractBackend::screensQueried, this, &WaylandTestApplication::continueStartupWithScreens);
disconnect(kwinApp()->platform(), &AbstractBackend::screensQueried, this, &WaylandTestApplication::continueStartupWithScreens);
createScreens();
waylandServer()->initOutputs();

70
autotests/wayland/lockscreen.cpp
View file

@ -128,19 +128,19 @@ Q_SIGNALS:
QVERIFY(!waylandServer()->isScreenLocked());
#define MOTION(target) \
waylandServer()->backend()->pointerMotion(target, timestamp++)
kwinApp()->platform()->pointerMotion(target, timestamp++)
#define PRESS \
waylandServer()->backend()->pointerButtonPressed(BTN_LEFT, timestamp++)
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++)
#define RELEASE \
waylandServer()->backend()->pointerButtonReleased(BTN_LEFT, timestamp++)
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++)
#define KEYPRESS( key ) \
waylandServer()->backend()->keyboardKeyPressed(key, timestamp++)
kwinApp()->platform()->keyboardKeyPressed(key, timestamp++)
#define KEYRELEASE( key ) \
waylandServer()->backend()->keyboardKeyReleased(key, timestamp++)
kwinApp()->platform()->keyboardKeyReleased(key, timestamp++)
void LockScreenTest::unlock()
{
@ -196,8 +196,8 @@ void LockScreenTest::initTestCase()
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
@ -390,24 +390,24 @@ void LockScreenTest::testPointerAxis()
quint32 timestamp = 1;
MOTION(c->geometry().center());
// and simulate axis
waylandServer()->backend()->pointerAxisHorizontal(5.0, timestamp++);
kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
QVERIFY(axisChangedSpy.wait());
LOCK
// and simulate axis
waylandServer()->backend()->pointerAxisHorizontal(5.0, timestamp++);
kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
QVERIFY(!axisChangedSpy.wait(100));
waylandServer()->backend()->pointerAxisVertical(5.0, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
QVERIFY(!axisChangedSpy.wait(100));
// and unlock
UNLOCK
// and move axis again
waylandServer()->backend()->pointerAxisHorizontal(5.0, timestamp++);
kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
QVERIFY(axisChangedSpy.wait());
waylandServer()->backend()->pointerAxisVertical(5.0, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
QVERIFY(axisChangedSpy.wait());
}
@ -621,32 +621,32 @@ void LockScreenTest::testMoveWindow()
workspace()->slotWindowMove();
QCOMPARE(workspace()->getMovingClient(), c);
QVERIFY(c->isMove());
waylandServer()->backend()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
QEXPECT_FAIL("", "First event is ignored", Continue);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// TODO adjust once the expected fail is fixed
waylandServer()->backend()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// while locking our window should continue to be in move resize
LOCK
QCOMPARE(workspace()->getMovingClient(), c);
QVERIFY(c->isMove());
waylandServer()->backend()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
UNLOCK
QCOMPARE(workspace()->getMovingClient(), c);
QVERIFY(c->isMove());
waylandServer()->backend()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
waylandServer()->backend()->keyboardKeyPressed(KEY_ESC, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_ESC, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, timestamp++);
QVERIFY(!c->isMove());
}
@ -661,12 +661,12 @@ void LockScreenTest::testPointerShortcut()
// try to trigger the shortcut
quint32 timestamp = 1;
#define PERFORM(expectedCount) \
waylandServer()->backend()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
PRESS; \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount); \
RELEASE; \
waylandServer()->backend()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount);
@ -713,14 +713,14 @@ void LockScreenTest::testAxisShortcut()
// try to trigger the shortcut
quint32 timestamp = 1;
#define PERFORM(expectedCount) \
waylandServer()->backend()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
if (direction == Qt::Vertical) \
waylandServer()->backend()->pointerAxisVertical(sign * 5.0, timestamp++); \
kwinApp()->platform()->pointerAxisVertical(sign * 5.0, timestamp++); \
else \
waylandServer()->backend()->pointerAxisHorizontal(sign * 5.0, timestamp++); \
kwinApp()->platform()->pointerAxisHorizontal(sign * 5.0, timestamp++); \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount); \
waylandServer()->backend()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount);
@ -792,24 +792,24 @@ void LockScreenTest::testTouch()
QVERIFY(pointRemovedSpy.isValid());
quint32 timestamp = 1;
waylandServer()->backend()->touchDown(1, QPointF(25, 25), timestamp++);
kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
LOCK
QVERIFY(cancelSpy.wait());
waylandServer()->backend()->touchUp(1, timestamp++);
kwinApp()->platform()->touchUp(1, timestamp++);
QVERIFY(!pointRemovedSpy.wait(100));
waylandServer()->backend()->touchDown(1, QPointF(25, 25), timestamp++);
waylandServer()->backend()->touchMotion(1, QPointF(26, 26), timestamp++);
waylandServer()->backend()->touchUp(1, timestamp++);
kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
kwinApp()->platform()->touchMotion(1, QPointF(26, 26), timestamp++);
kwinApp()->platform()->touchUp(1, timestamp++);
UNLOCK
waylandServer()->backend()->touchDown(1, QPointF(25, 25), timestamp++);
kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 2);
waylandServer()->backend()->touchUp(1, timestamp++);
kwinApp()->platform()->touchUp(1, timestamp++);
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 1);
}

10
autotests/wayland/move_resize_window_test.cpp
View file

@ -83,7 +83,7 @@ void MoveResizeWindowTest::initTestCase()
qRegisterMetaType<KWin::MaximizeMode>("MaximizeMode");
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());
@ -506,22 +506,22 @@ void MoveResizeWindowTest::testPointerMoveEnd()
// let's trigger the left button
quint32 timestamp = 1;
waylandServer()->backend()->pointerButtonPressed(BTN_LEFT, timestamp++);
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
QVERIFY(!c->isMove());
workspace()->slotWindowMove();
QVERIFY(c->isMove());
// let's press another button
QFETCH(int, additionalButton);
waylandServer()->backend()->pointerButtonPressed(additionalButton, timestamp++);
kwinApp()->platform()->pointerButtonPressed(additionalButton, timestamp++);
QVERIFY(c->isMove());
// release the left button, should still have the window moving
waylandServer()->backend()->pointerButtonReleased(BTN_LEFT, timestamp++);
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
QVERIFY(c->isMove());
// but releasing the other button should now end moving
waylandServer()->backend()->pointerButtonReleased(additionalButton, timestamp++);
kwinApp()->platform()->pointerButtonReleased(additionalButton, timestamp++);
QVERIFY(!c->isMove());
}

2
autotests/wayland/platformcursor.cpp
View file

@ -39,7 +39,7 @@ void PlatformCursorTest::initTestCase()
{
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());

36
autotests/wayland/pointer_input.cpp
View file

@ -91,8 +91,8 @@ void PointerInputTest::initTestCase()
qRegisterMetaType<KWin::Deleted*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
@ -272,7 +272,7 @@ void PointerInputTest::testWarpingGeneratesPointerMotion()
QVERIFY(window);
// enter
waylandServer()->backend()->pointerMotion(QPointF(25, 25), 1);
kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
QVERIFY(enteredSpy.wait());
// we get a move event together with the enter, that's actually wrong but also shouldn't harm
QVERIFY(movedSpy.wait());
@ -317,8 +317,8 @@ void PointerInputTest::testUpdateFocusAfterScreenChange()
QSignalSpy screensChangedSpy(screens(), &Screens::changed);
QVERIFY(screensChangedSpy.isValid());
// now let's remove the screen containing the cursor
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 1));
QMetaObject::invokeMethod(waylandServer()->backend(), "sizeChanged", Qt::QueuedConnection);
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 1));
QMetaObject::invokeMethod(kwinApp()->platform(), "sizeChanged", Qt::QueuedConnection);
QVERIFY(screensChangedSpy.wait());
QCOMPARE(screens()->count(), 1);
@ -399,15 +399,15 @@ void PointerInputTest::testModifierClickUnrestrictedMove()
quint32 timestamp = 1;
QFETCH(int, modifierKey);
QFETCH(int, mouseButton);
waylandServer()->backend()->keyboardKeyPressed(modifierKey, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
QVERIFY(!window->isMove());
waylandServer()->backend()->pointerButtonPressed(mouseButton, timestamp++);
kwinApp()->platform()->pointerButtonPressed(mouseButton, timestamp++);
QVERIFY(window->isMove());
// release modifier should not change it
waylandServer()->backend()->keyboardKeyReleased(modifierKey, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
QVERIFY(window->isMove());
// but releasing the key should end move/resize
waylandServer()->backend()->pointerButtonReleased(mouseButton, timestamp++);
kwinApp()->platform()->pointerButtonReleased(mouseButton, timestamp++);
QVERIFY(!window->isMove());
// all of that should not have triggered button events on the surface
@ -471,12 +471,12 @@ void PointerInputTest::testModifierScrollOpacity()
// simulate modifier+wheel
quint32 timestamp = 1;
QFETCH(int, modifierKey);
waylandServer()->backend()->keyboardKeyPressed(modifierKey, timestamp++);
waylandServer()->backend()->pointerAxisVertical(-5, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
QCOMPARE(window->opacity(), 0.6);
waylandServer()->backend()->pointerAxisVertical(5, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
QCOMPARE(window->opacity(), 0.5);
waylandServer()->backend()->keyboardKeyReleased(modifierKey, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
// axis should have been filtered out
QCOMPARE(axisSpy.count(), 0);
@ -524,7 +524,7 @@ void PointerInputTest::testScrollAction()
quint32 timestamp = 1;
QVERIFY(!window1->isActive());
waylandServer()->backend()->pointerAxisVertical(5, timestamp++);
kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
QVERIFY(window1->isActive());
// but also the wheel event should be passed to the window
@ -689,7 +689,7 @@ void PointerInputTest::testMouseActionInactiveWindow()
// and click
quint32 timestamp = 1;
QFETCH(quint32, button);
waylandServer()->backend()->pointerButtonPressed(button, timestamp++);
kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
// should raise window1 and activate it
QCOMPARE(stackingOrderChangedSpy.count(), 1);
QVERIFY(!activeWindowChangedSpy.isEmpty());
@ -698,7 +698,7 @@ void PointerInputTest::testMouseActionInactiveWindow()
QVERIFY(!window2->isActive());
// release again
waylandServer()->backend()->pointerButtonReleased(button, timestamp++);
kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
}
void PointerInputTest::testMouseActionActiveWindow_data()
@ -773,7 +773,7 @@ void PointerInputTest::testMouseActionActiveWindow()
// and click
quint32 timestamp = 1;
QFETCH(quint32, button);
waylandServer()->backend()->pointerButtonPressed(button, timestamp++);
kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
QVERIFY(buttonSpy.wait());
if (clickRaise) {
QCOMPARE(stackingOrderChangedSpy.count(), 1);
@ -785,7 +785,7 @@ void PointerInputTest::testMouseActionActiveWindow()
}
// release again
waylandServer()->backend()->pointerButtonReleased(button, timestamp++);
kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
}
void PointerInputTest::testCursorImage()

34
autotests/wayland/quick_tiling_test.cpp
View file

@ -76,8 +76,8 @@ void QuickTilingTest::initTestCase()
qRegisterMetaType<KWin::MaximizeMode>("MaximizeMode");
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
// set custom config which disables the Outline
@ -428,26 +428,26 @@ void QuickTilingTest::testQuickTilingKeyboardMove()
QFETCH(QPoint, targetPos);
quint32 timestamp = 1;
waylandServer()->backend()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
while (Cursor::pos().x() > targetPos.x()) {
waylandServer()->backend()->keyboardKeyPressed(KEY_LEFT, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_LEFT, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_LEFT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_LEFT, timestamp++);
}
while (Cursor::pos().x() < targetPos.x()) {
waylandServer()->backend()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
}
while (Cursor::pos().y() < targetPos.y()) {
waylandServer()->backend()->keyboardKeyPressed(KEY_DOWN, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_DOWN, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_DOWN, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_DOWN, timestamp++);
}
while (Cursor::pos().y() > targetPos.y()) {
waylandServer()->backend()->keyboardKeyPressed(KEY_UP, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_UP, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_UP, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_UP, timestamp++);
}
waylandServer()->backend()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
waylandServer()->backend()->keyboardKeyPressed(KEY_ENTER, timestamp++);
waylandServer()->backend()->keyboardKeyReleased(KEY_ENTER, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
kwinApp()->platform()->keyboardKeyPressed(KEY_ENTER, timestamp++);
kwinApp()->platform()->keyboardKeyReleased(KEY_ENTER, timestamp++);
QCOMPARE(Cursor::pos(), targetPos);
QVERIFY(!workspace()->getMovingClient());
@ -509,9 +509,9 @@ void QuickTilingTest::testQuickTilingPointerMove()
QFETCH(QPoint, targetPos);
quint32 timestamp = 1;
waylandServer()->backend()->pointerMotion(targetPos, timestamp++);
waylandServer()->backend()->pointerButtonPressed(BTN_LEFT, timestamp++);
waylandServer()->backend()->pointerButtonReleased(BTN_LEFT, timestamp++);
kwinApp()->platform()->pointerMotion(targetPos, timestamp++);
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
QCOMPARE(Cursor::pos(), targetPos);
QVERIFY(!workspace()->getMovingClient());

2
autotests/wayland/start_test.cpp
View file

@ -51,7 +51,7 @@ void StartTest::initTestCase()
{
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());

24
autotests/wayland/touch_input_test.cpp
View file

@ -69,8 +69,8 @@ void TouchInputTest::initTestCase()
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
@ -219,7 +219,7 @@ void TouchInputTest::testMultipleTouchPoints()
QVERIFY(endedSpy.isValid());
quint32 timestamp = 1;
waylandServer()->backend()->touchDown(1, QPointF(125, 125), timestamp++);
kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 1);
@ -229,7 +229,7 @@ void TouchInputTest::testMultipleTouchPoints()
QCOMPARE(pointMovedSpy.count(), 0);
// a point outside the window
waylandServer()->backend()->touchDown(2, QPointF(0, 0), timestamp++);
kwinApp()->platform()->touchDown(2, QPointF(0, 0), timestamp++);
QVERIFY(pointAddedSpy.wait());
QCOMPARE(pointAddedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 2);
@ -238,21 +238,21 @@ void TouchInputTest::testMultipleTouchPoints()
QCOMPARE(pointMovedSpy.count(), 0);
// let's move that one
waylandServer()->backend()->touchMotion(2, QPointF(100, 100), timestamp++);
kwinApp()->platform()->touchMotion(2, QPointF(100, 100), timestamp++);
QVERIFY(pointMovedSpy.wait());
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 2);
QCOMPARE(m_touch->sequence().at(1)->isDown(), true);
QCOMPARE(m_touch->sequence().at(1)->position(), QPointF(0, 0));
waylandServer()->backend()->touchUp(1, timestamp++);
kwinApp()->platform()->touchUp(1, timestamp++);
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 2);
QCOMPARE(m_touch->sequence().first()->isDown(), false);
QCOMPARE(endedSpy.count(), 0);
waylandServer()->backend()->touchUp(2, timestamp++);
kwinApp()->platform()->touchUp(2, timestamp++);
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 2);
QCOMPARE(m_touch->sequence().count(), 2);
@ -275,16 +275,16 @@ void TouchInputTest::testCancel()
QVERIFY(pointRemovedSpy.isValid());
quint32 timestamp = 1;
waylandServer()->backend()->touchDown(1, QPointF(125, 125), timestamp++);
kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
// cancel
waylandServer()->backend()->touchCancel();
kwinApp()->platform()->touchCancel();
QVERIFY(cancelSpy.wait());
QCOMPARE(cancelSpy.count(), 1);
waylandServer()->backend()->touchUp(1, timestamp++);
kwinApp()->platform()->touchUp(1, timestamp++);
QVERIFY(!pointRemovedSpy.wait(100));
QCOMPARE(pointRemovedSpy.count(), 0);
}
@ -307,14 +307,14 @@ void TouchInputTest::testTouchMouseAction()
QVERIFY(sequenceStartedSpy.isValid());
quint32 timestamp = 1;
waylandServer()->backend()->touchDown(1, c1->geometry().center(), timestamp++);
kwinApp()->platform()->touchDown(1, c1->geometry().center(), timestamp++);
QVERIFY(c1->isActive());
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
// cleanup
waylandServer()->backend()->touchCancel();
kwinApp()->platform()->touchCancel();
}
}

2
autotests/wayland/transient_no_input_test.cpp
View file

@ -61,7 +61,7 @@ void TransientNoInputTest::initTestCase()
qRegisterMetaType<KWin::ShellClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());

4
autotests/wayland/transient_placement.cpp
View file

@ -79,8 +79,8 @@ void TransientPlacementTest::initTestCase()
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(waylandServer()->backend(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
waylandServer()->init(s_socketName.toLocal8Bit());
kwinApp()->start();

3
backends/hwcomposer/hwcomposer_backend.cpp
View file

@ -23,6 +23,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "screens_hwcomposer.h"
#include "composite.h"
#include "input.h"
#include "main.h"
#include "virtual_terminal.h"
#include "wayland_server.h"
// KWayland
@ -225,7 +226,7 @@ void HwcomposerBackend::init()
if (disp != 0) {
return;
}
dynamic_cast<HwcomposerBackend*>(waylandServer()->backend())->wakeVSync();
dynamic_cast<HwcomposerBackend*>(kwinApp()->platform())->wakeVSync();
};
procs->hotplug = [] (const struct hwc_procs* procs, int disp, int connected) {
Q_UNUSED(procs)

8
composite.cpp
View file

@ -116,10 +116,10 @@ Compositor::Compositor(QObject* workspace)
m_unusedSupportPropertyTimer.setSingleShot(true);
connect(&m_unusedSupportPropertyTimer, SIGNAL(timeout()), SLOT(deleteUnusedSupportProperties()));
if (kwinApp()->operationMode() != Application::OperationModeX11) {
if (waylandServer()->backend()->isReady()) {
if (kwinApp()->platform()->isReady()) {
QMetaObject::invokeMethod(this, "setup", Qt::QueuedConnection);
}
connect(waylandServer()->backend(), &AbstractBackend::readyChanged, this,
connect(kwinApp()->platform(), &AbstractBackend::readyChanged, this,
[this] (bool ready) {
if (ready) {
setup();
@ -649,7 +649,7 @@ void Compositor::performCompositing()
// If outputs are disabled, we return to the event loop and
// continue processing events until the outputs are enabled again
if (waylandServer() && !waylandServer()->backend()->areOutputsEnabled()) {
if (waylandServer() && !kwinApp()->platform()->areOutputsEnabled()) {
compositeTimer.stop();
return;
}
@ -796,7 +796,7 @@ void Compositor::setCompositeTimer()
return;
// Don't start the timer if all outputs are disabled
if (waylandServer() && !waylandServer()->backend()->areOutputsEnabled()) {
if (waylandServer() && !kwinApp()->platform()->areOutputsEnabled()) {
return;
}

12
main_wayland.cpp
View file

@ -84,7 +84,7 @@ ApplicationWayland::~ApplicationWayland()
return;
}
waylandServer()->backend()->setOutputsEnabled(false);
kwinApp()->platform()->setOutputsEnabled(false);
destroyWorkspace();
waylandServer()->dispatch();
// need to unload all effects prior to destroying X connection as they might do X calls
@ -130,7 +130,7 @@ void ApplicationWayland::setupCrashHandler()
void ApplicationWayland::createBackend()
{
AbstractBackend *backend = waylandServer()->backend();
AbstractBackend *backend = kwinApp()->platform();
connect(backend, &AbstractBackend::screensQueried, this, &ApplicationWayland::continueStartupWithScreens);
connect(backend, &AbstractBackend::initFailed, this,
[] () {
@ -143,7 +143,7 @@ void ApplicationWayland::createBackend()
void ApplicationWayland::continueStartupWithScreens()
{
disconnect(waylandServer()->backend(), &AbstractBackend::screensQueried, this, &ApplicationWayland::continueStartupWithScreens);
disconnect(kwinApp()->platform(), &AbstractBackend::screensQueried, this, &ApplicationWayland::continueStartupWithScreens);
createScreens();
waylandServer()->initOutputs();
@ -699,12 +699,12 @@ int main(int argc, char * argv[])
return 1;
}
if (!deviceIdentifier.isEmpty()) {
server->backend()->setDeviceIdentifier(deviceIdentifier);
a.platform()->setDeviceIdentifier(deviceIdentifier);
}
if (initialWindowSize.isValid()) {
server->backend()->setInitialWindowSize(initialWindowSize);
a.platform()->setInitialWindowSize(initialWindowSize);
}
server->backend()->setInitialOutputCount(outputCount);
a.platform()->setInitialOutputCount(outputCount);
QObject::connect(&a, &KWin::Application::workspaceCreated, server, &KWin::WaylandServer::initWorkspace);
environment.insert(QStringLiteral("WAYLAND_DISPLAY"), server->display()->socketName());

2
plugins/qpa/integration.cpp
View file

@ -145,7 +145,7 @@ QPlatformNativeInterface *Integration::nativeInterface() const
QPlatformOpenGLContext *Integration::createPlatformOpenGLContext(QOpenGLContext *context) const
{
if (waylandServer()->backend()->supportsQpaContext()) {
if (kwinApp()->platform()->supportsQpaContext()) {
return new SharingPlatformContext(context, const_cast<Integration*>(this));
}
if (m_eglDisplay == EGL_NO_DISPLAY) {

4
plugins/qpa/sharingplatformcontext.cpp
View file

@ -33,7 +33,7 @@ namespace QPA
{
SharingPlatformContext::SharingPlatformContext(QOpenGLContext *context, Integration *integration)
: AbstractPlatformContext(context, integration, waylandServer()->backend()->sceneEglDisplay())
: AbstractPlatformContext(context, integration, kwinApp()->platform()->sceneEglDisplay())
{
create();
}
@ -85,7 +85,7 @@ void SharingPlatformContext::create()
if (!bindApi()) {
return;
}
createContext(waylandServer()->backend()->sceneEglContext());
createContext(kwinApp()->platform()->sceneEglContext());
}
}

6
pointer_input.cpp
View file

@ -122,7 +122,7 @@ void PointerInputRedirection::init()
Q_ASSERT(!m_inited);
m_cursor = new CursorImage(this);
m_inited = true;
connect(m_cursor, &CursorImage::changed, waylandServer()->backend(), &AbstractBackend::cursorChanged);
connect(m_cursor, &CursorImage::changed, kwinApp()->platform(), &AbstractBackend::cursorChanged);
emit m_cursor->changed();
connect(workspace(), &Workspace::stackingOrderChanged, this, &PointerInputRedirection::update);
connect(screens(), &Screens::changed, this, &PointerInputRedirection::updateAfterScreenChange);
@ -437,7 +437,7 @@ void PointerInputRedirection::updateButton(uint32_t button, InputRedirection::Po
void PointerInputRedirection::warp(const QPointF &pos)
{
if (supportsWarping()) {
waylandServer()->backend()->warpPointer(pos);
kwinApp()->platform()->warpPointer(pos);
processMotion(pos, waylandServer()->seat()->timestamp());
}
}
@ -450,7 +450,7 @@ bool PointerInputRedirection::supportsWarping() const
if (m_supportsWarping) {
return true;
}
if (waylandServer()->backend()->supportsPointerWarping()) {
if (kwinApp()->platform()->supportsPointerWarping()) {
return true;
}
return false;

2
scene_opengl.cpp
View file

@ -572,7 +572,7 @@ SceneOpenGL *SceneOpenGL::createScene(QObject *parent)
break;
case EglPlatformInterface:
if (kwinApp()->shouldUseWaylandForCompositing()) {
backend = waylandServer()->backend()->createOpenGLBackend();
backend = kwinApp()->platform()->createOpenGLBackend();
} else {
backend = new EglOnXBackend();
}

2
scene_qpainter.cpp
View file

@ -96,7 +96,7 @@ SceneQPainter *SceneQPainter::createScene(QObject *parent)
{
QScopedPointer<QPainterBackend> backend;
if (kwinApp()->shouldUseWaylandForCompositing()) {
backend.reset(waylandServer()->backend()->createQPainterBackend());
backend.reset(kwinApp()->platform()->createQPainterBackend());
if (backend.isNull()) {
return nullptr;
}

2
screens.cpp
View file

@ -43,7 +43,7 @@ Screens *Screens::create(QObject *parent)
s_self = new MockScreens(parent);
#else
if (kwinApp()->shouldUseWaylandForCompositing()) {
s_self = waylandServer()->backend()->createScreens(parent);
s_self = kwinApp()->platform()->createScreens(parent);
}
if (kwinApp()->operationMode() == Application::OperationModeX11) {
s_self = new XRandRScreens(parent);