kde-fix
/
kwin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[tests] Add a sub-surface test application

Browse Source 
The test application creates a sub-surface tree consisting of overall
three surfaces:
* blue main surface
* red sub surface
* green sub surface to the red sub surface

All surfaces are in synchronized mode. There is a timer to turn the
green surface into yellow after five seconds.
master
Martin Gräßlin 9 years ago
parent 35e50175fd
commit 598896987b
2 changed files with 213 additions and 0 deletions
Show Stats Download Patch File Download Diff File

4
src/wayland/tests/CMakeLists.txt
Unescape Escape View File

@ -51,3 +51,7 @@ if (Qt5Widgets_FOUND)
target_link_libraries(dpmsTest KF5::WaylandClient Qt5::Widgets)
ecm_mark_as_test(dpmsTest)
endif()
add_executable(subsurface-test subsurfacetest.cpp)
target_link_libraries(subsurface-test Qt5::Core Qt5::Gui KF5::WaylandClient)
ecm_mark_as_test(subsurface-test)

209
src/wayland/tests/subsurfacetest.cpp
Unescape Escape View File

@ -0,0 +1,209 @@
/********************************************************************
Copyright 2016 Martin Gräßlin <mgraesslin@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), which shall
act as a proxy defined in Section 6 of version 3 of the license.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "../src/client/compositor.h"
#include "../src/client/connection_thread.h"
#include "../src/client/datadevice.h"
#include "../src/client/datadevicemanager.h"
#include "../src/client/dataoffer.h"
#include "../src/client/event_queue.h"
#include "../src/client/keyboard.h"
#include "../src/client/registry.h"
#include "../src/client/seat.h"
#include "../src/client/shell.h"
#include "../src/client/shm_pool.h"
#include "../src/client/subcompositor.h"
#include "../src/client/surface.h"
// Qt
#include <QGuiApplication>
#include <QDebug>
#include <QFile>
#include <QImage>
#include <QMimeType>
#include <QThread>
#include <QTimer>
// system
#include <unistd.h>
#include <linux/input.h>
using namespace KWayland::Client;
class SubSurfaceTest : public QObject
{
Q_OBJECT
public:
explicit SubSurfaceTest(QObject *parent = nullptr);
virtual ~SubSurfaceTest();
void init();
private:
void setupRegistry(Registry *registry);
void render();
QThread *m_connectionThread;
ConnectionThread *m_connectionThreadObject;
EventQueue *m_eventQueue = nullptr;
Compositor *m_compositor = nullptr;
Seat *m_seat = nullptr;
Shell *m_shell = nullptr;
ShellSurface *m_shellSurface = nullptr;
ShmPool *m_shm = nullptr;
Surface *m_surface = nullptr;
SubCompositor *m_subCompositor = nullptr;
};
SubSurfaceTest::SubSurfaceTest(QObject *parent)
: QObject(parent)
, m_connectionThread(new QThread(this))
, m_connectionThreadObject(new ConnectionThread())
{
}
SubSurfaceTest::~SubSurfaceTest()
{
m_connectionThread->quit();
m_connectionThread->wait();
m_connectionThreadObject->deleteLater();
}
void SubSurfaceTest::init()
{
connect(m_connectionThreadObject, &ConnectionThread::connected, this,
[this] {
m_eventQueue = new EventQueue(this);
m_eventQueue->setup(m_connectionThreadObject);
Registry *registry = new Registry(this);
setupRegistry(registry);
},
Qt::QueuedConnection
);
m_connectionThreadObject->moveToThread(m_connectionThread);
m_connectionThread->start();
m_connectionThreadObject->initConnection();
}
void SubSurfaceTest::setupRegistry(Registry *registry)
{
connect(registry, &Registry::compositorAnnounced, this,
[this, registry](quint32 name, quint32 version) {
m_compositor = registry->createCompositor(name, version, this);
}
);
connect(registry, &Registry::shellAnnounced, this,
[this, registry](quint32 name, quint32 version) {
m_shell = registry->createShell(name, version, this);
}
);
connect(registry, &Registry::shmAnnounced, this,
[this, registry](quint32 name, quint32 version) {
m_shm = registry->createShmPool(name, version, this);
}
);
connect(registry, &Registry::seatAnnounced, this,
[this, registry](quint32 name, quint32 version) {
m_seat = registry->createSeat(name, version, this);
}
);
connect(registry, &Registry::interfacesAnnounced, this,
[this, registry] {
Q_ASSERT(m_compositor);
Q_ASSERT(m_seat);
Q_ASSERT(m_shell);
Q_ASSERT(m_shm);
m_surface = m_compositor->createSurface(this);
Q_ASSERT(m_surface);
m_shellSurface = m_shell->createSurface(m_surface, this);
Q_ASSERT(m_shellSurface);
m_shellSurface->setToplevel();
connect(m_shellSurface, &ShellSurface::sizeChanged, this, &SubSurfaceTest::render);
auto subInterface = registry->interface(Registry::Interface::SubCompositor);
if (subInterface.name != 0) {
m_subCompositor = registry->createSubCompositor(subInterface.name, subInterface.version, this);
Q_ASSERT(m_subCompositor);
// create the sub surface
auto surface = m_compositor->createSurface(this);
Q_ASSERT(surface);
auto subsurface = m_subCompositor->createSubSurface(surface, m_surface, this);
Q_ASSERT(subsurface);
QImage image(QSize(100, 100), QImage::Format_ARGB32_Premultiplied);
image.fill(Qt::red);
surface->attachBuffer(m_shm->createBuffer(image));
surface->damage(QRect(0, 0, 100, 100));
surface->commit(Surface::CommitFlag::None);
// and another sub-surface to the sub-surface
auto surface2 = m_compositor->createSurface(this);
Q_ASSERT(surface2);
auto subsurface2 = m_subCompositor->createSubSurface(surface2, surface, this);
Q_ASSERT(subsurface2);
QImage green(QSize(50, 50), QImage::Format_ARGB32_Premultiplied);
green.fill(Qt::green);
surface2->attachBuffer(m_shm->createBuffer(green));
surface2->damage(QRect(0, 0, 50, 50));
surface2->commit(Surface::CommitFlag::None);
QTimer *timer = new QTimer(this);
connect(timer, &QTimer::timeout, surface2,
[surface2, this] {
QImage yellow(QSize(50, 50), QImage::Format_ARGB32_Premultiplied);
yellow.fill(Qt::yellow);
surface2->attachBuffer(m_shm->createBuffer(yellow));
surface2->damage(QRect(0, 0, 50, 50));
surface2->commit(Surface::CommitFlag::None);
m_surface->commit(Surface::CommitFlag::None);
}
);
timer->setSingleShot(true);
timer->start(5000);
}
render();
}
);
registry->setEventQueue(m_eventQueue);
registry->create(m_connectionThreadObject);
registry->setup();
}
void SubSurfaceTest::render()
{
const QSize &size = m_shellSurface->size().isValid() ? m_shellSurface->size() : QSize(200, 200);
auto buffer = m_shm->getBuffer(size, size.width() * 4).toStrongRef();
buffer->setUsed(true);
QImage image(buffer->address(), size.width(), size.height(), QImage::Format_ARGB32_Premultiplied);
image.fill(Qt::blue);
m_surface->attachBuffer(*buffer);
m_surface->damage(QRect(QPoint(0, 0), size));
m_surface->commit(Surface::CommitFlag::None);
buffer->setUsed(false);
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
SubSurfaceTest client;
client.init();
return app.exec();
}
#include "subsurfacetest.moc"
Write Preview
Loading…
Cancel
Save