yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/wayland/autotests/server/test_viewporter_interface.cpp

192 lines
6.7 KiB
C++
Raw Normal View History

Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
/*
SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#include <QThread>
#include <QtTest>
Integrate kwaylandserver This makes KWin switch to in-tree copy of KWaylandServer codebase. KWaylandServer namespace has been left as is. It will be addressed later by renaming classes in order to fit in the KWin namespace.
2022-04-22 09:27:33 +00:00
#include "wayland/compositor_interface.h"
#include "wayland/display.h"
#include "wayland/surface_interface.h"
#include "wayland/viewporter_interface.h"
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
#include "KWayland/Client/compositor.h"
#include "KWayland/Client/connection_thread.h"
#include "KWayland/Client/event_queue.h"
#include "KWayland/Client/registry.h"
#include "KWayland/Client/shm_pool.h"
#include "KWayland/Client/surface.h"
#include "qwayland-viewporter.h"
using namespace KWaylandServer;
class Viewporter : public QtWayland::wp_viewporter
{
};
class Viewport : public QtWayland::wp_viewport
{
};
class TestViewporterInterface : public QObject
{
Q_OBJECT
public:
~TestViewporterInterface() override;
private Q_SLOTS:
void initTestCase();
void testCropScale();
private:
KWayland::Client::ConnectionThread *m_connection;
KWayland::Client::EventQueue *m_queue;
KWayland::Client::Compositor *m_clientCompositor;
KWayland::Client::ShmPool *m_shm;
QThread *m_thread;
Disambiguate KWaylandServer::Display This unfortunately clashes with a typedef in a Qt6 header.
2022-03-05 12:02:08 +00:00
KWaylandServer::Display m_display;
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
CompositorInterface *m_serverCompositor;
Viewporter *m_viewporter;
};
static const QString s_socketName = QStringLiteral("kwin-wayland-server-viewporter-test-0");
void TestViewporterInterface::initTestCase()
{
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
m_display.addSocketName(s_socketName);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
m_display.start();
QVERIFY(m_display.isRunning());
m_display.createShm();
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
new ViewporterInterface(&m_display);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
m_serverCompositor = new CompositorInterface(&m_display, this);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
m_connection = new KWayland::Client::ConnectionThread;
QSignalSpy connectedSpy(m_connection, &KWayland::Client::ConnectionThread::connected);
m_connection->setSocketName(s_socketName);
m_thread = new QThread(this);
m_connection->moveToThread(m_thread);
m_thread->start();
m_connection->initConnection();
QVERIFY(connectedSpy.wait());
QVERIFY(!m_connection->connections().isEmpty());
m_queue = new KWayland::Client::EventQueue(this);
QVERIFY(!m_queue->isValid());
m_queue->setup(m_connection);
QVERIFY(m_queue->isValid());
auto registry = new KWayland::Client::Registry(this);
connect(registry, &KWayland::Client::Registry::interfaceAnnounced, this, [this, registry](const QByteArray &interface, quint32 id, quint32 version) {
if (interface == QByteArrayLiteral("wp_viewporter")) {
m_viewporter = new Viewporter();
m_viewporter->init(*registry, id, version);
}
});
QSignalSpy allAnnouncedSpy(registry, &KWayland::Client::Registry::interfaceAnnounced);
QSignalSpy compositorSpy(registry, &KWayland::Client::Registry::compositorAnnounced);
QSignalSpy shmSpy(registry, &KWayland::Client::Registry::shmAnnounced);
registry->setEventQueue(m_queue);
registry->create(m_connection->display());
QVERIFY(registry->isValid());
registry->setup();
QVERIFY(allAnnouncedSpy.wait());
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
m_clientCompositor = registry->createCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>(), this);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QVERIFY(m_clientCompositor->isValid());
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
m_shm = registry->createShmPool(shmSpy.first().first().value<quint32>(), shmSpy.first().last().value<quint32>(), this);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QVERIFY(m_shm->isValid());
}
TestViewporterInterface::~TestViewporterInterface()
{
if (m_viewporter) {
delete m_viewporter;
m_viewporter = nullptr;
}
if (m_shm) {
delete m_shm;
m_shm = nullptr;
}
if (m_queue) {
delete m_queue;
m_queue = nullptr;
}
if (m_thread) {
m_thread->quit();
m_thread->wait();
delete m_thread;
m_thread = nullptr;
}
m_connection->deleteLater();
m_connection = nullptr;
}
void TestViewporterInterface::testCropScale()
{
// Create a test surface.
QSignalSpy serverSurfaceCreatedSpy(m_serverCompositor, &CompositorInterface::surfaceCreated);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Surface> clientSurface(m_clientCompositor->createSurface(this));
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QVERIFY(serverSurfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = serverSurfaceCreatedSpy.first().first().value<SurfaceInterface *>();
QVERIFY(serverSurface);
QSignalSpy serverSurfaceMappedSpy(serverSurface, &SurfaceInterface::mapped);
QSignalSpy serverSurfaceSizeChangedSpy(serverSurface, &SurfaceInterface::sizeChanged);
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QSignalSpy surfaceToBufferMatrixChangedSpy(serverSurface, &SurfaceInterface::surfaceToBufferMatrixChanged);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
// Map the surface.
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QImage image(QSize(200, 100), QImage::Format_ARGB32_Premultiplied);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
image.fill(Qt::black);
KWayland::Client::Buffer::Ptr buffer = m_shm->createBuffer(image);
clientSurface->attachBuffer(buffer);
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
clientSurface->setScale(2);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
clientSurface->damage(image.rect());
clientSurface->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(serverSurfaceMappedSpy.wait());
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(surfaceToBufferMatrixChangedSpy.count(), 1);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QCOMPARE(serverSurface->size(), QSize(100, 50));
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(serverSurface->mapToBuffer(QPointF(0, 0)), QPointF(0, 0));
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
// Create a viewport for the surface.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<Viewport> clientViewport(new Viewport);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
clientViewport->init(m_viewporter->get_viewport(*clientSurface));
// Crop the surface.
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
clientViewport->set_source(wl_fixed_from_double(10), wl_fixed_from_double(10), wl_fixed_from_double(30), wl_fixed_from_double(20));
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
clientSurface->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(serverSurfaceSizeChangedSpy.wait());
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(surfaceToBufferMatrixChangedSpy.count(), 2);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QCOMPARE(serverSurface->size(), QSize(30, 20));
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(serverSurface->mapToBuffer(QPointF(0, 0)), QPointF(20, 20));
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
// Scale the surface.
clientViewport->set_destination(500, 250);
clientSurface->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(serverSurfaceSizeChangedSpy.wait());
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(surfaceToBufferMatrixChangedSpy.count(), 3);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QCOMPARE(serverSurface->size(), QSize(500, 250));
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(serverSurface->mapToBuffer(QPointF(0, 0)), QPointF(20, 20));
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
// If the viewport is destroyed, the crop and scale state will be unset on a next commit.
clientViewport->destroy();
clientSurface->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(serverSurfaceSizeChangedSpy.wait());
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(surfaceToBufferMatrixChangedSpy.count(), 4);
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
QCOMPARE(serverSurface->size(), QSize(100, 50));
Introduce surface-to-buffer and buffer-to-surface matrices The compositor needs to monitor changes in the mapping between the surface local coordinates and the buffer coordinates because texture coordinates correspond to the latter. One way to do it is to monitor things such as the surface size, the buffer size, the buffer scale, etc. The main problem with doing so is that there are so many factors that contribute to how mapping between the surface local coordinate space and the buffer coordinate space is performed. In order to provide a generic way for monitoring changes in the mapping between the surface local coordinate space and the buffer coordinate space, this patch introduces two new matrices. The first one specifies how the surface-local coordinates are mapped to buffer coordinates, and the other one specifies how to map the buffer coordinates to surface local coordinates. With the new two matrices, the compositor has a generic way to get notified when it has to re-compute texture coordinates.
2020-06-10 07:42:16 +00:00
QCOMPARE(serverSurface->mapToBuffer(QPointF(0, 0)), QPointF(0, 0));
Add support for the wp_viewporter protocol The wp_viewporter compositor extension allows clients to crop and scale their surface. It can be useful for applications such as video players because it may potentially reduce their power usage.
2020-05-24 10:46:27 +00:00
}
QTEST_GUILESS_MAIN(TestViewporterInterface)
#include "test_viewporter_interface.moc"
Reference in a new issue Copy permalink