Commit d0c488f4 authored by Martin Flöser's avatar Martin Flöser

Announce output changes to Wayland for platforms not handling outputs

Summary:
Most platforms like the nested and virtual do not handle the outputs
themselves and WaylandServer announces the Outputs to Wayland.

So far this was static: at startup it got announced once to Wayland
and any changes were not catched.

This change makes WaylandServer listen to changes to the Screens and
sync them to Wayland.

Unfortunately KWin's internal Screen information is not sufficient to
properly synchronize this to Wayland and also Wayland by not supporting
adding/removing modes does not help.

Thus the solution implemented here is to add new outputs reflecting the
changes and then removing the old ones. This creates situations with more
outputs being present than actually there, but prevents that there are
no outputs at all.

Test Plan: Auto test added which verifies this for the virtual platform

Reviewers: #kwin, #plasma_on_wayland

Subscribers: plasma-devel, kwin

Tags: #plasma_on_wayland, #kwin

Differential Revision: https://phabricator.kde.org/D2233
parent a95be71e
......@@ -36,6 +36,7 @@ integrationTest(NAME testDontCrashNoBorder SRCS dont_crash_no_border.cpp)
integrationTest(NAME testXClipboardSync SRCS xclipboardsync_test.cpp)
integrationTest(NAME testSceneQPainter SRCS scene_qpainter_test.cpp)
integrationTest(NAME testNoXdgRuntimeDir SRCS no_xdg_runtime_dir_test.cpp)
integrationTest(NAME testScreenChanges SRCS screen_changes_test.cpp)
if (XCB_ICCCM_FOUND)
integrationTest(NAME testMoveResize SRCS move_resize_window_test.cpp LIBS XCB::ICCCM)
......
/********************************************************************
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"
#include "platform.h"
#include "screens.h"
#include "wayland_server.h"
#include <KWayland/Client/output.h>
#include <KWayland/Client/registry.h>
using namespace KWin;
using namespace KWayland::Client;
static const QString s_socketName = QStringLiteral("wayland_test_kwin_screen_changes-0");
class ScreenChangesTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testScreenAddRemove();
};
void ScreenChangesTest::initTestCase()
{
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());
setenv("QT_QPA_PLATFORM", "wayland", true);
waylandServer()->initWorkspace();
}
void ScreenChangesTest::init()
{
QVERIFY(Test::setupWaylandConnection(s_socketName));
screens()->setCurrent(0);
KWin::Cursor::setPos(QPoint(640, 512));
}
void ScreenChangesTest::cleanup()
{
Test::destroyWaylandConnection();
}
void ScreenChangesTest::testScreenAddRemove()
{
// this test verifies that when a new screen is added it gets synced to Wayland
// first create a registry to get signals about Outputs announced/removed
Registry registry;
QSignalSpy allAnnounced(&registry, &Registry::interfacesAnnounced);
QVERIFY(allAnnounced.isValid());
QSignalSpy outputAnnouncedSpy(&registry, &Registry::outputAnnounced);
QVERIFY(outputAnnouncedSpy.isValid());
QSignalSpy outputRemovedSpy(&registry, &Registry::outputRemoved);
QVERIFY(outputRemovedSpy.isValid());
registry.create(Test::waylandConnection());
QVERIFY(registry.isValid());
registry.setup();
QVERIFY(allAnnounced.wait());
// should be one output
QCOMPARE(screens()->count(), 1);
QCOMPARE(outputAnnouncedSpy.count(), 1);
const quint32 firstOutputId = outputAnnouncedSpy.first().first().value<quint32>();
QVERIFY(firstOutputId != 0u);
outputAnnouncedSpy.clear();
// let's announce a new output
QSignalSpy screensChangedSpy(screens(), &Screens::changed);
QVERIFY(screensChangedSpy.isValid());
const QVector<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
QMetaObject::invokeMethod(kwinApp()->platform(), "outputGeometriesChanged",
Qt::DirectConnection,
Q_ARG(QVector<QRect>, geometries));
QVERIFY(screensChangedSpy.wait());
QCOMPARE(screensChangedSpy.count(), 1);
QCOMPARE(screens()->count(), 2);
QCOMPARE(screens()->geometry(0), geometries.at(0));
QCOMPARE(screens()->geometry(1), geometries.at(1));
// this should result in it getting announced, two new outputs are added...
QVERIFY(outputAnnouncedSpy.wait());
if (outputAnnouncedSpy.count() < 2) {
QVERIFY(outputAnnouncedSpy.wait());
}
QCOMPARE(outputAnnouncedSpy.count(), 2);
// ... and afterward the previous output gets removed
if (outputRemovedSpy.isEmpty()) {
QVERIFY(outputRemovedSpy.wait());
}
QCOMPARE(outputRemovedSpy.count(), 1);
QCOMPARE(outputRemovedSpy.first().first().value<quint32>(), firstOutputId);
// let's wait a little bit to ensure we don't get more events
QTest::qWait(100);
QCOMPARE(outputAnnouncedSpy.count(), 2);
QCOMPARE(outputRemovedSpy.count(), 1);
// let's create the output objects to ensure they are correct
QScopedPointer<Output> o1(registry.createOutput(outputAnnouncedSpy.first().first().value<quint32>(), outputAnnouncedSpy.first().last().value<quint32>()));
QVERIFY(o1->isValid());
QSignalSpy o1ChangedSpy(o1.data(), &Output::changed);
QVERIFY(o1ChangedSpy.isValid());
QVERIFY(o1ChangedSpy.wait());
QCOMPARE(o1->geometry(), geometries.at(0));
QScopedPointer<Output> o2(registry.createOutput(outputAnnouncedSpy.last().first().value<quint32>(), outputAnnouncedSpy.last().last().value<quint32>()));
QVERIFY(o2->isValid());
QSignalSpy o2ChangedSpy(o2.data(), &Output::changed);
QVERIFY(o2ChangedSpy.isValid());
QVERIFY(o2ChangedSpy.wait());
QCOMPARE(o2->geometry(), geometries.at(1));
// now let's try to remove one output again
outputAnnouncedSpy.clear();
outputRemovedSpy.clear();
screensChangedSpy.clear();
QSignalSpy o1RemovedSpy(o1.data(), &Output::removed);
QVERIFY(o1RemovedSpy.isValid());
QSignalSpy o2RemovedSpy(o2.data(), &Output::removed);
QVERIFY(o2RemovedSpy.isValid());
const QVector<QRect> geometries2{QRect(0, 0, 1280, 1024)};
QMetaObject::invokeMethod(kwinApp()->platform(), "outputGeometriesChanged",
Qt::DirectConnection,
Q_ARG(QVector<QRect>, geometries2));
QVERIFY(screensChangedSpy.wait());
QCOMPARE(screensChangedSpy.count(), 1);
QCOMPARE(screens()->count(), 1);
QCOMPARE(screens()->geometry(0), geometries2.at(0));
QVERIFY(outputAnnouncedSpy.wait());
QCOMPARE(outputAnnouncedSpy.count(), 1);
if (o1RemovedSpy.isEmpty()) {
QVERIFY(o1RemovedSpy.wait());
}
if (o2RemovedSpy.isEmpty()) {
QVERIFY(o2RemovedSpy.wait());
}
// now wait a bit to ensure we don't get more events
QTest::qWait(100);
QCOMPARE(outputAnnouncedSpy.count(), 1);
QCOMPARE(o1RemovedSpy.count(), 1);
QCOMPARE(o2RemovedSpy.count(), 1);
QCOMPARE(outputRemovedSpy.count(), 2);
}
WAYLANDTEST_MAIN(ScreenChangesTest)
#include "screen_changes_test.moc"
......@@ -38,9 +38,13 @@ void VirtualScreens::init()
this, &VirtualScreens::startChangedTimer);
connect(m_backend, &VirtualBackend::outputGeometriesChanged, this,
[this] (const QVector<QRect> &geometries) {
// TODO: update Wayland Output
const int oldCount = m_geometries.count();
m_geometries = geometries;
emit changed();
if (oldCount != m_geometries.count()) {
setCount(m_geometries.count());
} else {
emit changed();
}
}
);
updateCount();
......
......@@ -330,6 +330,22 @@ void WaylandServer::initOutputs()
if (kwinApp()->platform()->handlesOutputs()) {
return;
}
syncOutputsToWayland();
connect(screens(), &Screens::changed, this,
[this] {
// when screens change we need to sync this to Wayland.
// Unfortunately we don't have much information and cannot properly match a KWin screen
// to a Wayland screen.
// Thus we just recreate all outputs and delete the old ones
const auto outputs = m_display->outputs();
syncOutputsToWayland();
qDeleteAll(outputs);
}
);
}
void WaylandServer::syncOutputsToWayland()
{
Screens *s = screens();
Q_ASSERT(s);
for (int i = 0; i < s->count(); ++i) {
......
......@@ -172,6 +172,7 @@ private:
void setupX11ClipboardSync();
void shellClientShown(Toplevel *t);
void initOutputs();
void syncOutputsToWayland();
quint16 createClientId(KWayland::Server::ClientConnection *c);
void destroyInternalConnection();
void configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment