2020-03-15 15:19:28 +00:00
|
|
|
/*
|
|
|
|
SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
|
2020-07-04 07:51:33 +00:00
|
|
|
SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
|
2014-08-28 07:52:35 +00:00
|
|
|
|
2020-03-15 15:19:28 +00:00
|
|
|
SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
|
|
|
|
*/
|
2014-08-28 07:52:35 +00:00
|
|
|
#include "surface_interface.h"
|
2014-10-14 12:04:35 +00:00
|
|
|
#include "surface_interface_p.h"
|
2014-08-28 12:22:53 +00:00
|
|
|
#include "buffer_interface.h"
|
2014-11-19 15:53:56 +00:00
|
|
|
#include "clientconnection.h"
|
2014-08-28 07:52:35 +00:00
|
|
|
#include "compositor_interface.h"
|
2020-07-04 07:51:33 +00:00
|
|
|
#include "display.h"
|
2017-10-20 16:28:25 +00:00
|
|
|
#include "idleinhibit_interface_p.h"
|
2016-11-08 13:17:15 +00:00
|
|
|
#include "pointerconstraints_interface_p.h"
|
2014-10-16 12:59:01 +00:00
|
|
|
#include "region_interface.h"
|
2014-10-14 12:04:35 +00:00
|
|
|
#include "subcompositor_interface.h"
|
|
|
|
#include "subsurface_interface_p.h"
|
2019-09-05 10:57:35 +00:00
|
|
|
#include "surfacerole_p.h"
|
2014-10-14 12:04:35 +00:00
|
|
|
// std
|
|
|
|
#include <algorithm>
|
2014-08-28 07:52:35 +00:00
|
|
|
|
2020-04-29 14:56:38 +00:00
|
|
|
namespace KWaylandServer
|
2014-08-28 07:52:35 +00:00
|
|
|
{
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
QList<SurfaceInterface *> SurfaceInterfacePrivate::surfaces;
|
|
|
|
|
|
|
|
KWaylandFrameCallback::KWaylandFrameCallback(wl_resource *resource, SurfaceInterface *surface)
|
|
|
|
: QtWaylandServer::wl_callback(resource)
|
|
|
|
, surface(surface)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void KWaylandFrameCallback::destroy()
|
2014-08-28 07:52:35 +00:00
|
|
|
{
|
2020-07-04 07:51:33 +00:00
|
|
|
wl_resource_destroy(resource()->handle);
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void KWaylandFrameCallback::callback_destroy_resource(Resource *)
|
2014-08-28 07:52:35 +00:00
|
|
|
{
|
2020-07-04 07:51:33 +00:00
|
|
|
if (surface) {
|
|
|
|
SurfaceInterfacePrivate *surfacePrivate = SurfaceInterfacePrivate::get(surface);
|
|
|
|
surfacePrivate->current.frameCallbacks.removeOne(this);
|
|
|
|
surfacePrivate->pending.frameCallbacks.removeOne(this);
|
2020-07-04 12:13:47 +00:00
|
|
|
surfacePrivate->cached.frameCallbacks.removeOne(this);
|
2020-07-04 07:51:33 +00:00
|
|
|
}
|
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
|
|
|
|
SurfaceInterfacePrivate::SurfaceInterfacePrivate(SurfaceInterface *q)
|
|
|
|
: q(q)
|
|
|
|
{
|
|
|
|
surfaces.append(q);
|
|
|
|
}
|
|
|
|
|
|
|
|
SurfaceInterfacePrivate::~SurfaceInterfacePrivate()
|
|
|
|
{
|
|
|
|
for (KWaylandFrameCallback *frameCallback : current.frameCallbacks) {
|
|
|
|
frameCallback->destroy();
|
|
|
|
}
|
|
|
|
for (KWaylandFrameCallback *frameCallback : pending.frameCallbacks) {
|
|
|
|
frameCallback->destroy();
|
|
|
|
}
|
2020-07-04 12:13:47 +00:00
|
|
|
for (KWaylandFrameCallback *frameCallback : cached.frameCallbacks) {
|
2020-07-04 07:51:33 +00:00
|
|
|
frameCallback->destroy();
|
|
|
|
}
|
|
|
|
if (current.buffer) {
|
|
|
|
current.buffer->unref();
|
|
|
|
}
|
|
|
|
surfaces.removeOne(q);
|
2014-09-19 05:06:31 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::addChild(QPointer<SubSurfaceInterface> child)
|
2014-10-14 12:04:35 +00:00
|
|
|
{
|
2016-03-21 14:53:13 +00:00
|
|
|
// protocol is not precise on how to handle the addition of new sub surfaces
|
|
|
|
pending.children.append(child);
|
2020-07-04 12:13:47 +00:00
|
|
|
cached.children.append(child);
|
2016-03-21 14:53:13 +00:00
|
|
|
current.children.append(child);
|
2020-02-21 22:13:08 +00:00
|
|
|
emit q->childSubSurfaceAdded(child);
|
2016-03-21 13:32:31 +00:00
|
|
|
emit q->subSurfaceTreeChanged();
|
|
|
|
QObject::connect(child.data(), &SubSurfaceInterface::positionChanged, q, &SurfaceInterface::subSurfaceTreeChanged);
|
|
|
|
QObject::connect(child->surface().data(), &SurfaceInterface::damaged, q, &SurfaceInterface::subSurfaceTreeChanged);
|
|
|
|
QObject::connect(child->surface().data(), &SurfaceInterface::unmapped, q, &SurfaceInterface::subSurfaceTreeChanged);
|
|
|
|
QObject::connect(child->surface().data(), &SurfaceInterface::subSurfaceTreeChanged, q, &SurfaceInterface::subSurfaceTreeChanged);
|
2014-10-14 12:04:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::removeChild(QPointer<SubSurfaceInterface> child)
|
2014-10-14 12:04:35 +00:00
|
|
|
{
|
2016-03-21 14:53:13 +00:00
|
|
|
// protocol is not precise on how to handle the addition of new sub surfaces
|
|
|
|
pending.children.removeAll(child);
|
2020-07-04 12:13:47 +00:00
|
|
|
cached.children.removeAll(child);
|
2016-03-21 14:53:13 +00:00
|
|
|
current.children.removeAll(child);
|
2020-02-21 22:13:08 +00:00
|
|
|
emit q->childSubSurfaceRemoved(child);
|
2016-03-21 13:32:31 +00:00
|
|
|
emit q->subSurfaceTreeChanged();
|
|
|
|
QObject::disconnect(child.data(), &SubSurfaceInterface::positionChanged, q, &SurfaceInterface::subSurfaceTreeChanged);
|
2016-03-24 11:45:46 +00:00
|
|
|
if (!child->surface().isNull()) {
|
|
|
|
QObject::disconnect(child->surface().data(), &SurfaceInterface::damaged, q, &SurfaceInterface::subSurfaceTreeChanged);
|
|
|
|
QObject::disconnect(child->surface().data(), &SurfaceInterface::unmapped, q, &SurfaceInterface::subSurfaceTreeChanged);
|
|
|
|
QObject::disconnect(child->surface().data(), &SurfaceInterface::subSurfaceTreeChanged, q, &SurfaceInterface::subSurfaceTreeChanged);
|
|
|
|
}
|
2014-10-14 12:04:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
bool SurfaceInterfacePrivate::raiseChild(QPointer<SubSurfaceInterface> subsurface, SurfaceInterface *sibling)
|
2014-10-14 12:04:35 +00:00
|
|
|
{
|
|
|
|
auto it = std::find(pending.children.begin(), pending.children.end(), subsurface);
|
|
|
|
if (it == pending.children.end()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (pending.children.count() == 1) {
|
|
|
|
// nothing to do
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (sibling == q) {
|
|
|
|
// it's to the parent, so needs to become last item
|
|
|
|
pending.children.append(*it);
|
|
|
|
pending.children.erase(it);
|
2016-03-18 08:57:46 +00:00
|
|
|
pending.childrenChanged = true;
|
2014-10-14 12:04:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (!sibling->subSurface()) {
|
|
|
|
// not a sub surface
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
auto siblingIt = std::find(pending.children.begin(), pending.children.end(), sibling->subSurface());
|
|
|
|
if (siblingIt == pending.children.end() || siblingIt == it) {
|
|
|
|
// not a sibling
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
auto value = (*it);
|
|
|
|
pending.children.erase(it);
|
|
|
|
// find the iterator again
|
|
|
|
siblingIt = std::find(pending.children.begin(), pending.children.end(), sibling->subSurface());
|
|
|
|
pending.children.insert(++siblingIt, value);
|
2016-03-18 08:57:46 +00:00
|
|
|
pending.childrenChanged = true;
|
2014-10-14 12:04:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
bool SurfaceInterfacePrivate::lowerChild(QPointer<SubSurfaceInterface> subsurface, SurfaceInterface *sibling)
|
2014-10-14 12:04:35 +00:00
|
|
|
{
|
|
|
|
auto it = std::find(pending.children.begin(), pending.children.end(), subsurface);
|
|
|
|
if (it == pending.children.end()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (pending.children.count() == 1) {
|
|
|
|
// nothing to do
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (sibling == q) {
|
|
|
|
// it's to the parent, so needs to become first item
|
|
|
|
auto value = *it;
|
|
|
|
pending.children.erase(it);
|
|
|
|
pending.children.prepend(value);
|
2016-03-18 08:57:46 +00:00
|
|
|
pending.childrenChanged = true;
|
2014-10-14 12:04:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (!sibling->subSurface()) {
|
|
|
|
// not a sub surface
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
auto siblingIt = std::find(pending.children.begin(), pending.children.end(), sibling->subSurface());
|
|
|
|
if (siblingIt == pending.children.end() || siblingIt == it) {
|
|
|
|
// not a sibling
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
auto value = (*it);
|
|
|
|
pending.children.erase(it);
|
|
|
|
// find the iterator again
|
|
|
|
siblingIt = std::find(pending.children.begin(), pending.children.end(), sibling->subSurface());
|
|
|
|
pending.children.insert(siblingIt, value);
|
2016-03-18 08:57:46 +00:00
|
|
|
pending.childrenChanged = true;
|
2014-10-14 12:04:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::setShadow(const QPointer<ShadowInterface> &shadow)
|
2015-07-15 09:07:50 +00:00
|
|
|
{
|
|
|
|
pending.shadow = shadow;
|
|
|
|
pending.shadowIsSet = true;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::setBlur(const QPointer<BlurInterface> &blur)
|
2015-08-26 12:42:58 +00:00
|
|
|
{
|
|
|
|
pending.blur = blur;
|
|
|
|
pending.blurIsSet = true;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::setSlide(const QPointer<SlideInterface> &slide)
|
2015-09-09 11:04:11 +00:00
|
|
|
{
|
|
|
|
pending.slide = slide;
|
|
|
|
pending.slideIsSet = true;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::setContrast(const QPointer<ContrastInterface> &contrast)
|
2015-09-02 16:13:25 +00:00
|
|
|
{
|
|
|
|
pending.contrast = contrast;
|
|
|
|
pending.contrastIsSet = true;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::installPointerConstraint(LockedPointerInterface *lock)
|
2016-11-08 13:17:15 +00:00
|
|
|
{
|
|
|
|
Q_ASSERT(lockedPointer.isNull());
|
|
|
|
Q_ASSERT(confinedPointer.isNull());
|
|
|
|
lockedPointer = QPointer<LockedPointerInterface>(lock);
|
2018-05-29 08:35:28 +00:00
|
|
|
|
|
|
|
auto cleanUp = [this]() {
|
|
|
|
lockedPointer.clear();
|
2020-07-04 07:51:33 +00:00
|
|
|
QObject::disconnect(constrainsOneShotConnection);
|
2018-05-29 08:35:28 +00:00
|
|
|
constrainsOneShotConnection = QMetaObject::Connection();
|
2020-07-04 07:51:33 +00:00
|
|
|
QObject::disconnect(constrainsUnboundConnection);
|
2018-05-29 08:35:28 +00:00
|
|
|
constrainsUnboundConnection = QMetaObject::Connection();
|
2020-07-04 07:51:33 +00:00
|
|
|
emit q->pointerConstraintsChanged();
|
2018-05-29 08:35:28 +00:00
|
|
|
};
|
|
|
|
|
2016-11-08 13:17:15 +00:00
|
|
|
if (lock->lifeTime() == LockedPointerInterface::LifeTime::OneShot) {
|
2020-07-04 07:51:33 +00:00
|
|
|
constrainsOneShotConnection = QObject::connect(lock, &LockedPointerInterface::lockedChanged, q,
|
2018-05-29 08:35:28 +00:00
|
|
|
[this, cleanUp] {
|
|
|
|
if (lockedPointer.isNull() || lockedPointer->isLocked()) {
|
2016-11-08 13:17:15 +00:00
|
|
|
return;
|
|
|
|
}
|
2018-05-29 08:35:28 +00:00
|
|
|
cleanUp();
|
2016-11-08 13:17:15 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
2020-07-04 07:51:33 +00:00
|
|
|
constrainsUnboundConnection = QObject::connect(lock, &LockedPointerInterface::unbound, q,
|
2018-05-29 08:35:28 +00:00
|
|
|
[this, cleanUp] {
|
2016-11-08 13:17:15 +00:00
|
|
|
if (lockedPointer.isNull()) {
|
|
|
|
return;
|
|
|
|
}
|
2018-05-29 08:35:28 +00:00
|
|
|
cleanUp();
|
2016-11-08 13:17:15 +00:00
|
|
|
}
|
|
|
|
);
|
2020-07-04 07:51:33 +00:00
|
|
|
emit q->pointerConstraintsChanged();
|
2016-11-08 13:17:15 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::installPointerConstraint(ConfinedPointerInterface *confinement)
|
2016-11-08 13:17:15 +00:00
|
|
|
{
|
|
|
|
Q_ASSERT(lockedPointer.isNull());
|
|
|
|
Q_ASSERT(confinedPointer.isNull());
|
|
|
|
confinedPointer = QPointer<ConfinedPointerInterface>(confinement);
|
2018-05-29 08:35:28 +00:00
|
|
|
|
|
|
|
auto cleanUp = [this]() {
|
|
|
|
confinedPointer.clear();
|
2020-07-04 07:51:33 +00:00
|
|
|
QObject::disconnect(constrainsOneShotConnection);
|
2018-05-29 08:35:28 +00:00
|
|
|
constrainsOneShotConnection = QMetaObject::Connection();
|
2020-07-04 07:51:33 +00:00
|
|
|
QObject::disconnect(constrainsUnboundConnection);
|
2018-05-29 08:35:28 +00:00
|
|
|
constrainsUnboundConnection = QMetaObject::Connection();
|
2020-07-04 07:51:33 +00:00
|
|
|
emit q->pointerConstraintsChanged();
|
2018-05-29 08:35:28 +00:00
|
|
|
};
|
|
|
|
|
2016-11-08 13:17:15 +00:00
|
|
|
if (confinement->lifeTime() == ConfinedPointerInterface::LifeTime::OneShot) {
|
2020-07-04 07:51:33 +00:00
|
|
|
constrainsOneShotConnection = QObject::connect(confinement, &ConfinedPointerInterface::confinedChanged, q,
|
2018-05-29 08:35:28 +00:00
|
|
|
[this, cleanUp] {
|
|
|
|
if (confinedPointer.isNull() || confinedPointer->isConfined()) {
|
2016-11-08 13:17:15 +00:00
|
|
|
return;
|
|
|
|
}
|
2018-05-29 08:35:28 +00:00
|
|
|
cleanUp();
|
2016-11-08 13:17:15 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
2020-07-04 07:51:33 +00:00
|
|
|
constrainsUnboundConnection = QObject::connect(confinement, &ConfinedPointerInterface::unbound, q,
|
2018-05-29 08:35:28 +00:00
|
|
|
[this, cleanUp] {
|
2016-11-08 13:17:15 +00:00
|
|
|
if (confinedPointer.isNull()) {
|
|
|
|
return;
|
|
|
|
}
|
2018-05-29 08:35:28 +00:00
|
|
|
cleanUp();
|
2016-11-08 13:17:15 +00:00
|
|
|
}
|
|
|
|
);
|
2020-07-04 07:51:33 +00:00
|
|
|
emit q->pointerConstraintsChanged();
|
2016-11-08 13:17:15 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::installIdleInhibitor(IdleInhibitorInterface *inhibitor)
|
2018-05-29 08:35:28 +00:00
|
|
|
{
|
|
|
|
idleInhibitors << inhibitor;
|
|
|
|
QObject::connect(inhibitor, &IdleInhibitorInterface::aboutToBeUnbound, q,
|
|
|
|
[this, inhibitor] {
|
|
|
|
idleInhibitors.removeOne(inhibitor);
|
|
|
|
if (idleInhibitors.isEmpty()) {
|
2020-07-04 07:51:33 +00:00
|
|
|
emit q->inhibitsIdleChanged();
|
2018-05-29 08:35:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
if (idleInhibitors.count() == 1) {
|
2020-07-04 07:51:33 +00:00
|
|
|
emit q->inhibitsIdleChanged();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_destroy_resource(Resource *)
|
|
|
|
{
|
|
|
|
emit q->aboutToBeUnbound();
|
|
|
|
delete q;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_destroy(Resource *resource)
|
|
|
|
{
|
|
|
|
wl_resource_destroy(resource->handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_attach(Resource *resource, struct ::wl_resource *buffer, int32_t x, int32_t y)
|
|
|
|
{
|
|
|
|
Q_UNUSED(resource)
|
|
|
|
pending.bufferIsSet = true;
|
|
|
|
pending.offset = QPoint(x, y);
|
|
|
|
if (pending.buffer) {
|
|
|
|
delete pending.buffer;
|
|
|
|
}
|
|
|
|
if (!buffer) {
|
|
|
|
// got a null buffer, deletes content in next frame
|
|
|
|
pending.buffer = nullptr;
|
|
|
|
pending.damage = QRegion();
|
|
|
|
pending.bufferDamage = QRegion();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pending.buffer = new BufferInterface(buffer, q);
|
|
|
|
QObject::connect(pending.buffer, &BufferInterface::aboutToBeDestroyed, q,
|
|
|
|
[this](BufferInterface *buffer) {
|
|
|
|
if (pending.buffer == buffer) {
|
|
|
|
pending.buffer = nullptr;
|
|
|
|
}
|
2020-07-04 12:13:47 +00:00
|
|
|
if (cached.buffer == buffer) {
|
|
|
|
cached.buffer = nullptr;
|
2020-07-04 07:51:33 +00:00
|
|
|
}
|
|
|
|
if (current.buffer == buffer) {
|
|
|
|
current.buffer->unref();
|
|
|
|
current.buffer = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_damage(Resource *, int32_t x, int32_t y, int32_t width, int32_t height)
|
|
|
|
{
|
|
|
|
pending.damage = pending.damage.united(QRect(x, y, width, height));
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_frame(Resource *resource, uint32_t callback)
|
|
|
|
{
|
|
|
|
wl_resource *callbackResource = wl_resource_create(resource->client(), &wl_callback_interface,
|
|
|
|
/* version */ 1, callback);
|
|
|
|
if (!callbackResource) {
|
|
|
|
wl_resource_post_no_memory(resource->handle);
|
|
|
|
return;
|
2018-05-29 08:35:28 +00:00
|
|
|
}
|
2020-07-04 07:51:33 +00:00
|
|
|
pending.frameCallbacks.append(new KWaylandFrameCallback(callbackResource, q));
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_set_opaque_region(Resource *resource, struct ::wl_resource *region)
|
|
|
|
{
|
|
|
|
Q_UNUSED(resource)
|
|
|
|
RegionInterface *r = RegionInterface::get(region);
|
|
|
|
pending.opaque = r ? r->region() : QRegion();
|
|
|
|
pending.opaqueIsSet = true;
|
|
|
|
|
2018-05-29 08:35:28 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::surface_set_input_region(Resource *resource, struct ::wl_resource *region)
|
|
|
|
{
|
|
|
|
Q_UNUSED(resource)
|
|
|
|
RegionInterface *r = RegionInterface::get(region);
|
|
|
|
pending.input = r ? r->region() : QRegion();
|
|
|
|
pending.inputIsInfinite = !r;
|
|
|
|
pending.inputIsSet = true;
|
|
|
|
}
|
2014-09-19 05:06:31 +00:00
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::surface_commit(Resource *resource)
|
2014-09-19 05:06:31 +00:00
|
|
|
{
|
2020-07-04 07:51:33 +00:00
|
|
|
Q_UNUSED(resource)
|
|
|
|
commit();
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::surface_set_buffer_transform(Resource *resource, int32_t transform)
|
|
|
|
{
|
|
|
|
Q_UNUSED(resource)
|
|
|
|
pending.bufferTransform = OutputInterface::Transform(transform);
|
|
|
|
pending.bufferTransformIsSet = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_set_buffer_scale(Resource *resource, int32_t scale)
|
|
|
|
{
|
|
|
|
Q_UNUSED(resource)
|
|
|
|
pending.bufferScale = scale;
|
|
|
|
pending.bufferScaleIsSet = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterfacePrivate::surface_damage_buffer(Resource *resource, int32_t x, int32_t y, int32_t width, int32_t height)
|
|
|
|
{
|
|
|
|
Q_UNUSED(resource)
|
|
|
|
pending.bufferDamage = pending.bufferDamage.united(QRect(x, y, width, height));
|
|
|
|
}
|
|
|
|
|
|
|
|
SurfaceInterface::SurfaceInterface(CompositorInterface *compositor, wl_resource *resource)
|
|
|
|
: QObject(compositor)
|
|
|
|
, d(new SurfaceInterfacePrivate(this))
|
|
|
|
{
|
|
|
|
d->compositor = compositor;
|
|
|
|
d->init(resource);
|
|
|
|
}
|
|
|
|
|
|
|
|
SurfaceInterface::~SurfaceInterface()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SurfaceInterface::id() const
|
|
|
|
{
|
|
|
|
return wl_resource_get_id(resource());
|
|
|
|
}
|
|
|
|
|
|
|
|
ClientConnection *SurfaceInterface::client() const
|
|
|
|
{
|
|
|
|
return d->compositor->display()->getConnection(d->resource()->client());
|
|
|
|
}
|
|
|
|
|
|
|
|
wl_resource *SurfaceInterface::resource() const
|
|
|
|
{
|
|
|
|
return d->resource()->handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
CompositorInterface *SurfaceInterface::compositor() const
|
|
|
|
{
|
|
|
|
return d->compositor;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<SurfaceInterface *> SurfaceInterface::surfaces()
|
|
|
|
{
|
|
|
|
return SurfaceInterfacePrivate::surfaces;
|
|
|
|
}
|
2014-09-19 05:06:31 +00:00
|
|
|
|
2014-08-28 07:52:35 +00:00
|
|
|
void SurfaceInterface::frameRendered(quint32 msec)
|
|
|
|
{
|
|
|
|
// notify all callbacks
|
2020-07-04 07:51:33 +00:00
|
|
|
const bool needsFlush = !d->current.frameCallbacks.isEmpty();
|
|
|
|
while (!d->current.frameCallbacks.isEmpty()) {
|
|
|
|
KWaylandFrameCallback *frameCallback = d->current.frameCallbacks.takeFirst();
|
|
|
|
frameCallback->send_done(msec);
|
|
|
|
frameCallback->destroy();
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
2016-03-18 08:13:27 +00:00
|
|
|
for (auto it = d->current.children.constBegin(); it != d->current.children.constEnd(); ++it) {
|
|
|
|
const auto &subSurface = *it;
|
|
|
|
if (subSurface.isNull() || subSurface->d_func()->surface.isNull()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
subSurface->d_func()->surface->frameRendered(msec);
|
|
|
|
}
|
2015-11-04 13:50:15 +00:00
|
|
|
if (needsFlush) {
|
|
|
|
client()->flush();
|
|
|
|
}
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
QMatrix4x4 SurfaceInterfacePrivate::buildSurfaceToBufferMatrix(const State *state)
|
2020-06-10 07:42:16 +00:00
|
|
|
{
|
|
|
|
// The order of transforms is reversed, i.e. the viewport transform is the first one.
|
|
|
|
|
|
|
|
QMatrix4x4 surfaceToBufferMatrix;
|
|
|
|
|
|
|
|
if (!state->buffer) {
|
|
|
|
return surfaceToBufferMatrix;
|
|
|
|
}
|
|
|
|
|
2020-06-19 06:58:40 +00:00
|
|
|
surfaceToBufferMatrix.scale(state->bufferScale, state->bufferScale);
|
2020-06-10 07:42:16 +00:00
|
|
|
|
2020-06-19 06:58:40 +00:00
|
|
|
switch (state->bufferTransform) {
|
2020-06-10 07:42:16 +00:00
|
|
|
case OutputInterface::Transform::Normal:
|
|
|
|
case OutputInterface::Transform::Flipped:
|
|
|
|
break;
|
|
|
|
case OutputInterface::Transform::Rotated90:
|
|
|
|
case OutputInterface::Transform::Flipped90:
|
2020-06-19 06:58:40 +00:00
|
|
|
surfaceToBufferMatrix.translate(0, state->buffer->height() / state->bufferScale);
|
2020-06-10 07:42:16 +00:00
|
|
|
surfaceToBufferMatrix.rotate(-90, 0, 0, 1);
|
|
|
|
break;
|
|
|
|
case OutputInterface::Transform::Rotated180:
|
|
|
|
case OutputInterface::Transform::Flipped180:
|
2020-06-19 06:58:40 +00:00
|
|
|
surfaceToBufferMatrix.translate(state->buffer->width() / state->bufferScale,
|
|
|
|
state->buffer->height() / state->bufferScale);
|
2020-06-10 07:42:16 +00:00
|
|
|
surfaceToBufferMatrix.rotate(-180, 0, 0, 1);
|
|
|
|
break;
|
|
|
|
case OutputInterface::Transform::Rotated270:
|
|
|
|
case OutputInterface::Transform::Flipped270:
|
2020-06-19 06:58:40 +00:00
|
|
|
surfaceToBufferMatrix.translate(state->buffer->width() / state->bufferScale, 0);
|
2020-06-10 07:42:16 +00:00
|
|
|
surfaceToBufferMatrix.rotate(-270, 0, 0, 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-06-19 06:58:40 +00:00
|
|
|
switch (state->bufferTransform) {
|
2020-06-10 07:42:16 +00:00
|
|
|
case OutputInterface::Transform::Flipped:
|
|
|
|
case OutputInterface::Transform::Flipped180:
|
2020-06-19 06:58:40 +00:00
|
|
|
surfaceToBufferMatrix.translate(state->buffer->width() / state->bufferScale, 0);
|
2020-06-10 07:42:16 +00:00
|
|
|
surfaceToBufferMatrix.scale(-1, 1);
|
|
|
|
break;
|
|
|
|
case OutputInterface::Transform::Flipped90:
|
|
|
|
case OutputInterface::Transform::Flipped270:
|
2020-06-19 06:58:40 +00:00
|
|
|
surfaceToBufferMatrix.translate(state->buffer->height() / state->bufferScale, 0);
|
2020-06-10 07:42:16 +00:00
|
|
|
surfaceToBufferMatrix.scale(-1, 1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (state->sourceGeometry.isValid()) {
|
|
|
|
surfaceToBufferMatrix.translate(state->sourceGeometry.x(), state->sourceGeometry.y());
|
|
|
|
surfaceToBufferMatrix.scale(state->sourceGeometry.width() / state->size.width(),
|
|
|
|
state->sourceGeometry.height() / state->size.height());
|
|
|
|
}
|
|
|
|
|
|
|
|
return surfaceToBufferMatrix;
|
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::swapStates(State *source, State *target, bool emitChanged)
|
2014-08-28 07:52:35 +00:00
|
|
|
{
|
2020-05-24 15:27:38 +00:00
|
|
|
const bool bufferChanged = source->bufferIsSet;
|
2016-03-18 08:57:46 +00:00
|
|
|
const bool opaqueRegionChanged = source->opaqueIsSet;
|
|
|
|
const bool inputRegionChanged = source->inputIsSet;
|
2020-06-19 06:58:40 +00:00
|
|
|
const bool scaleFactorChanged = source->bufferScaleIsSet && (target->bufferScale != source->bufferScale);
|
|
|
|
const bool transformChanged = source->bufferTransformIsSet && (target->bufferTransform != source->bufferTransform);
|
2016-03-18 08:57:46 +00:00
|
|
|
const bool shadowChanged = source->shadowIsSet;
|
|
|
|
const bool blurChanged = source->blurIsSet;
|
|
|
|
const bool contrastChanged = source->contrastIsSet;
|
|
|
|
const bool slideChanged = source->slideIsSet;
|
|
|
|
const bool childrenChanged = source->childrenChanged;
|
2020-05-04 11:55:15 +00:00
|
|
|
const bool visibilityChanged = bufferChanged && (bool(source->buffer) != bool(target->buffer));
|
2020-05-24 10:46:27 +00:00
|
|
|
const QSize oldSize = target->size;
|
2020-06-30 06:06:53 +00:00
|
|
|
const QSize oldBufferSize = bufferSize;
|
2020-06-10 07:42:16 +00:00
|
|
|
const QMatrix4x4 oldSurfaceToBufferMatrix = surfaceToBufferMatrix;
|
2014-11-28 07:33:32 +00:00
|
|
|
if (bufferChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
// TODO: is the reffing correct for subsurfaces?
|
|
|
|
if (target->buffer) {
|
|
|
|
if (emitChanged) {
|
|
|
|
target->buffer->unref();
|
|
|
|
} else {
|
|
|
|
delete target->buffer;
|
|
|
|
target->buffer = nullptr;
|
|
|
|
}
|
2014-11-28 07:33:32 +00:00
|
|
|
}
|
2016-03-18 08:57:46 +00:00
|
|
|
if (source->buffer) {
|
|
|
|
if (emitChanged) {
|
|
|
|
source->buffer->ref();
|
|
|
|
}
|
2014-11-28 07:33:32 +00:00
|
|
|
}
|
2020-05-24 10:46:27 +00:00
|
|
|
target->buffer = source->buffer;
|
2020-02-06 11:20:44 +00:00
|
|
|
target->offset = source->offset;
|
2016-03-18 08:57:46 +00:00
|
|
|
target->damage = source->damage;
|
2019-05-08 07:38:37 +00:00
|
|
|
target->bufferDamage = source->bufferDamage;
|
2016-03-18 08:57:46 +00:00
|
|
|
target->bufferIsSet = source->bufferIsSet;
|
|
|
|
}
|
2020-05-24 10:46:27 +00:00
|
|
|
if (source->sourceGeometryIsSet) {
|
|
|
|
target->sourceGeometry = source->sourceGeometry;
|
|
|
|
target->sourceGeometryIsSet = true;
|
|
|
|
}
|
|
|
|
if (source->destinationSizeIsSet) {
|
|
|
|
target->destinationSize = source->destinationSize;
|
|
|
|
target->destinationSizeIsSet = true;
|
|
|
|
}
|
2016-03-18 08:57:46 +00:00
|
|
|
if (childrenChanged) {
|
|
|
|
target->childrenChanged = source->childrenChanged;
|
|
|
|
target->children = source->children;
|
2014-08-28 12:22:53 +00:00
|
|
|
}
|
2020-07-04 07:51:33 +00:00
|
|
|
target->frameCallbacks.append(source->frameCallbacks);
|
2016-03-18 08:57:46 +00:00
|
|
|
|
2015-07-15 09:07:50 +00:00
|
|
|
if (shadowChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
target->shadow = source->shadow;
|
|
|
|
target->shadowIsSet = true;
|
2015-07-15 09:07:50 +00:00
|
|
|
}
|
2015-08-26 12:42:58 +00:00
|
|
|
if (blurChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
target->blur = source->blur;
|
|
|
|
target->blurIsSet = true;
|
2015-08-26 12:42:58 +00:00
|
|
|
}
|
2015-09-02 16:13:25 +00:00
|
|
|
if (contrastChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
target->contrast = source->contrast;
|
|
|
|
target->contrastIsSet = true;
|
2015-09-02 16:13:25 +00:00
|
|
|
}
|
2015-09-09 11:04:11 +00:00
|
|
|
if (slideChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
target->slide = source->slide;
|
|
|
|
target->slideIsSet = true;
|
2015-09-09 11:04:11 +00:00
|
|
|
}
|
2016-03-18 08:57:46 +00:00
|
|
|
if (inputRegionChanged) {
|
|
|
|
target->input = source->input;
|
|
|
|
target->inputIsInfinite = source->inputIsInfinite;
|
|
|
|
target->inputIsSet = true;
|
|
|
|
}
|
|
|
|
if (opaqueRegionChanged) {
|
|
|
|
target->opaque = source->opaque;
|
|
|
|
target->opaqueIsSet = true;
|
|
|
|
}
|
|
|
|
if (scaleFactorChanged) {
|
2020-06-19 06:58:40 +00:00
|
|
|
target->bufferScale = source->bufferScale;
|
|
|
|
target->bufferScaleIsSet = true;
|
2016-03-18 08:57:46 +00:00
|
|
|
}
|
2016-03-23 13:34:51 +00:00
|
|
|
if (transformChanged) {
|
2020-06-19 06:58:40 +00:00
|
|
|
target->bufferTransform = source->bufferTransform;
|
|
|
|
target->bufferTransformIsSet = true;
|
2014-10-14 12:04:35 +00:00
|
|
|
}
|
2016-11-08 13:17:15 +00:00
|
|
|
if (!lockedPointer.isNull()) {
|
|
|
|
lockedPointer->d_func()->commit();
|
|
|
|
}
|
|
|
|
if (!confinedPointer.isNull()) {
|
|
|
|
confinedPointer->d_func()->commit();
|
|
|
|
}
|
2016-03-18 08:57:46 +00:00
|
|
|
|
|
|
|
*source = State{};
|
|
|
|
source->children = target->children;
|
2020-05-24 15:27:38 +00:00
|
|
|
|
|
|
|
if (!emitChanged) {
|
|
|
|
return;
|
|
|
|
}
|
2020-06-10 07:42:16 +00:00
|
|
|
// TODO: Refactor the state management code because it gets more clumsy.
|
2020-05-24 10:46:27 +00:00
|
|
|
if (target->buffer) {
|
2020-06-30 06:06:53 +00:00
|
|
|
bufferSize = target->buffer->size();
|
2020-05-24 10:46:27 +00:00
|
|
|
if (target->destinationSize.isValid()) {
|
|
|
|
target->size = target->destinationSize;
|
2020-06-10 07:42:16 +00:00
|
|
|
} else if (target->sourceGeometry.isValid()) {
|
|
|
|
target->size = target->sourceGeometry.size().toSize();
|
2020-05-24 10:46:27 +00:00
|
|
|
} else {
|
2020-06-19 06:58:40 +00:00
|
|
|
target->size = target->buffer->size() / target->bufferScale;
|
|
|
|
switch (target->bufferTransform) {
|
2020-06-10 07:42:16 +00:00
|
|
|
case OutputInterface::Transform::Rotated90:
|
|
|
|
case OutputInterface::Transform::Rotated270:
|
|
|
|
case OutputInterface::Transform::Flipped90:
|
|
|
|
case OutputInterface::Transform::Flipped270:
|
|
|
|
target->size.transpose();
|
|
|
|
break;
|
|
|
|
case OutputInterface::Transform::Normal:
|
|
|
|
case OutputInterface::Transform::Rotated180:
|
|
|
|
case OutputInterface::Transform::Flipped:
|
|
|
|
case OutputInterface::Transform::Flipped180:
|
|
|
|
break;
|
|
|
|
}
|
2020-05-24 10:46:27 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
target->size = QSize();
|
2020-06-30 06:06:53 +00:00
|
|
|
bufferSize = QSize();
|
2020-05-24 10:46:27 +00:00
|
|
|
}
|
2020-06-10 07:42:16 +00:00
|
|
|
surfaceToBufferMatrix = buildSurfaceToBufferMatrix(target);
|
|
|
|
bufferToSurfaceMatrix = surfaceToBufferMatrix.inverted();
|
2014-08-28 07:52:35 +00:00
|
|
|
if (opaqueRegionChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
emit q->opaqueChanged(target->opaque);
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
if (inputRegionChanged) {
|
2016-03-18 08:57:46 +00:00
|
|
|
emit q->inputChanged(target->input);
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
if (scaleFactorChanged) {
|
2020-06-19 06:58:40 +00:00
|
|
|
emit q->bufferScaleChanged(target->bufferScale);
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
2016-03-23 13:34:51 +00:00
|
|
|
if (transformChanged) {
|
2020-06-19 06:58:40 +00:00
|
|
|
emit q->bufferTransformChanged(target->bufferTransform);
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
2020-05-24 15:27:38 +00:00
|
|
|
if (visibilityChanged) {
|
|
|
|
if (target->buffer) {
|
|
|
|
subSurfaceIsMapped = true;
|
|
|
|
emit q->mapped();
|
|
|
|
} else {
|
|
|
|
subSurfaceIsMapped = false;
|
|
|
|
emit q->unmapped();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bufferChanged) {
|
2019-05-08 07:38:37 +00:00
|
|
|
if (target->buffer && (!target->damage.isEmpty() || !target->bufferDamage.isEmpty())) {
|
2015-05-26 09:37:00 +00:00
|
|
|
const QRegion windowRegion = QRegion(0, 0, q->size().width(), q->size().height());
|
2020-06-10 07:42:16 +00:00
|
|
|
const QRegion bufferDamage = q->mapFromBuffer(target->bufferDamage);
|
2020-06-10 07:53:36 +00:00
|
|
|
target->damage = windowRegion.intersected(target->damage.united(bufferDamage));
|
|
|
|
trackedDamage = trackedDamage.united(target->damage);
|
|
|
|
emit q->damaged(target->damage);
|
|
|
|
// workaround for https://bugreports.qt.io/browse/QTBUG-52092
|
|
|
|
// if the surface is a sub-surface, but the main surface is not yet mapped, fake frame rendered
|
|
|
|
if (subSurface) {
|
|
|
|
const auto mainSurface = subSurface->mainSurface();
|
|
|
|
if (!mainSurface || !mainSurface->buffer()) {
|
|
|
|
q->frameRendered(0);
|
2016-03-18 08:57:46 +00:00
|
|
|
}
|
2015-05-26 09:37:00 +00:00
|
|
|
}
|
2014-11-28 07:33:32 +00:00
|
|
|
}
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
2020-06-10 07:42:16 +00:00
|
|
|
if (surfaceToBufferMatrix != oldSurfaceToBufferMatrix) {
|
|
|
|
emit q->surfaceToBufferMatrixChanged();
|
|
|
|
}
|
2020-06-30 06:06:53 +00:00
|
|
|
if (bufferSize != oldBufferSize) {
|
|
|
|
emit q->bufferSizeChanged();
|
|
|
|
}
|
2020-05-24 10:46:27 +00:00
|
|
|
if (target->size != oldSize) {
|
2015-03-03 09:16:11 +00:00
|
|
|
emit q->sizeChanged();
|
|
|
|
}
|
2015-07-15 09:07:50 +00:00
|
|
|
if (shadowChanged) {
|
|
|
|
emit q->shadowChanged();
|
|
|
|
}
|
2015-08-26 12:42:58 +00:00
|
|
|
if (blurChanged) {
|
|
|
|
emit q->blurChanged();
|
|
|
|
}
|
2015-09-02 16:13:25 +00:00
|
|
|
if (contrastChanged) {
|
|
|
|
emit q->contrastChanged();
|
|
|
|
}
|
2015-09-09 11:04:11 +00:00
|
|
|
if (slideChanged) {
|
|
|
|
emit q->slideOnShowHideChanged();
|
|
|
|
}
|
2016-03-21 13:32:31 +00:00
|
|
|
if (childrenChanged) {
|
|
|
|
emit q->subSurfaceTreeChanged();
|
|
|
|
}
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::commit()
|
2016-03-18 08:57:46 +00:00
|
|
|
{
|
|
|
|
if (!subSurface.isNull() && subSurface->isSynchronized()) {
|
2020-07-04 12:13:47 +00:00
|
|
|
swapStates(&pending, &cached, false);
|
2016-03-18 08:57:46 +00:00
|
|
|
} else {
|
|
|
|
swapStates(&pending, ¤t, true);
|
|
|
|
if (!subSurface.isNull()) {
|
|
|
|
subSurface->d_func()->commit();
|
|
|
|
}
|
|
|
|
// commit all subSurfaces to apply position changes
|
|
|
|
// "The cached state is applied to the sub-surface immediately after the parent surface's state is applied"
|
|
|
|
for (auto it = current.children.constBegin(); it != current.children.constEnd(); ++it) {
|
|
|
|
const auto &subSurface = *it;
|
|
|
|
if (subSurface.isNull()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
subSurface->d_func()->commit();
|
|
|
|
}
|
|
|
|
}
|
2019-09-05 10:57:35 +00:00
|
|
|
if (role) {
|
|
|
|
role->commit();
|
|
|
|
}
|
2019-02-12 14:06:12 +00:00
|
|
|
emit q->committed();
|
2016-03-18 08:57:46 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
void SurfaceInterfacePrivate::commitSubSurface()
|
2016-03-18 08:57:46 +00:00
|
|
|
{
|
|
|
|
if (subSurface.isNull() || !subSurface->isSynchronized()) {
|
|
|
|
return;
|
|
|
|
}
|
2020-07-04 12:13:47 +00:00
|
|
|
swapStates(&cached, ¤t, true);
|
2016-03-18 08:57:46 +00:00
|
|
|
// "The cached state is applied to the sub-surface immediately after the parent surface's state is applied"
|
|
|
|
for (auto it = current.children.constBegin(); it != current.children.constEnd(); ++it) {
|
|
|
|
const auto &subSurface = *it;
|
|
|
|
if (subSurface.isNull() || !subSurface->isSynchronized()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
subSurface->d_func()->commit();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-19 05:06:31 +00:00
|
|
|
QRegion SurfaceInterface::damage() const
|
|
|
|
{
|
|
|
|
return d->current.damage;
|
|
|
|
}
|
|
|
|
|
|
|
|
QRegion SurfaceInterface::opaque() const
|
|
|
|
{
|
|
|
|
return d->current.opaque;
|
|
|
|
}
|
|
|
|
|
|
|
|
QRegion SurfaceInterface::input() const
|
|
|
|
{
|
|
|
|
return d->current.input;
|
|
|
|
}
|
|
|
|
|
2015-09-16 14:43:58 +00:00
|
|
|
bool SurfaceInterface::inputIsInfinite() const
|
2014-10-16 12:59:01 +00:00
|
|
|
{
|
|
|
|
return d->current.inputIsInfinite;
|
|
|
|
}
|
|
|
|
|
2020-06-19 06:58:40 +00:00
|
|
|
qint32 SurfaceInterface::bufferScale() const
|
2014-09-19 05:06:31 +00:00
|
|
|
{
|
2020-06-19 06:58:40 +00:00
|
|
|
return d->current.bufferScale;
|
2014-09-19 05:06:31 +00:00
|
|
|
}
|
|
|
|
|
2020-06-19 06:58:40 +00:00
|
|
|
OutputInterface::Transform SurfaceInterface::bufferTransform() const
|
2014-09-19 05:06:31 +00:00
|
|
|
{
|
2020-06-19 06:58:40 +00:00
|
|
|
return d->current.bufferTransform;
|
2014-09-19 05:06:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BufferInterface *SurfaceInterface::buffer()
|
|
|
|
{
|
|
|
|
return d->current.buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
QPoint SurfaceInterface::offset() const
|
|
|
|
{
|
|
|
|
return d->current.offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
SurfaceInterface *SurfaceInterface::get(wl_resource *native)
|
|
|
|
{
|
2020-07-04 07:51:33 +00:00
|
|
|
if (auto surface = SurfaceInterfacePrivate::Resource::fromResource(native)) {
|
|
|
|
return static_cast<SurfaceInterfacePrivate *>(surface->object())->q;
|
|
|
|
}
|
|
|
|
return nullptr;
|
2014-08-28 07:52:35 +00:00
|
|
|
}
|
|
|
|
|
2015-04-02 07:41:48 +00:00
|
|
|
SurfaceInterface *SurfaceInterface::get(quint32 id, const ClientConnection *client)
|
2015-02-09 13:31:20 +00:00
|
|
|
{
|
2020-07-04 07:51:33 +00:00
|
|
|
const QList<SurfaceInterface *> candidates = surfaces();
|
|
|
|
for (SurfaceInterface *surface : candidates) {
|
|
|
|
if (surface->client() == client && surface->id() == id) {
|
|
|
|
return surface;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
2015-02-09 13:31:20 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 12:04:35 +00:00
|
|
|
QList< QPointer< SubSurfaceInterface > > SurfaceInterface::childSubSurfaces() const
|
|
|
|
{
|
|
|
|
return d->current.children;
|
|
|
|
}
|
|
|
|
|
|
|
|
QPointer< SubSurfaceInterface > SurfaceInterface::subSurface() const
|
|
|
|
{
|
|
|
|
return d->subSurface;
|
|
|
|
}
|
|
|
|
|
2015-03-03 09:16:11 +00:00
|
|
|
QSize SurfaceInterface::size() const
|
|
|
|
{
|
2020-05-24 10:46:27 +00:00
|
|
|
return d->current.size;
|
|
|
|
}
|
|
|
|
|
2020-02-21 10:16:38 +00:00
|
|
|
QRect SurfaceInterface::boundingRect() const
|
|
|
|
{
|
|
|
|
QRect rect(QPoint(0, 0), size());
|
|
|
|
|
|
|
|
const QList<QPointer<SubSurfaceInterface>> subSurfaces = childSubSurfaces();
|
|
|
|
for (const SubSurfaceInterface *subSurface : subSurfaces) {
|
|
|
|
const SurfaceInterface *childSurface = subSurface->surface();
|
|
|
|
rect |= childSurface->boundingRect().translated(subSurface->position());
|
|
|
|
}
|
|
|
|
|
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
2015-07-15 09:07:50 +00:00
|
|
|
QPointer< ShadowInterface > SurfaceInterface::shadow() const
|
|
|
|
{
|
|
|
|
return d->current.shadow;
|
|
|
|
}
|
|
|
|
|
2015-08-26 12:42:58 +00:00
|
|
|
QPointer< BlurInterface > SurfaceInterface::blur() const
|
|
|
|
{
|
|
|
|
return d->current.blur;
|
|
|
|
}
|
|
|
|
|
2015-09-02 16:13:25 +00:00
|
|
|
QPointer< ContrastInterface > SurfaceInterface::contrast() const
|
|
|
|
{
|
|
|
|
return d->current.contrast;
|
|
|
|
}
|
|
|
|
|
2015-09-09 11:04:11 +00:00
|
|
|
QPointer< SlideInterface > SurfaceInterface::slideOnShowHide() const
|
|
|
|
{
|
|
|
|
return d->current.slide;
|
|
|
|
}
|
|
|
|
|
2016-03-29 10:05:05 +00:00
|
|
|
bool SurfaceInterface::isMapped() const
|
|
|
|
{
|
|
|
|
if (d->subSurface) {
|
|
|
|
// from spec:
|
|
|
|
// "A sub-surface becomes mapped, when a non-NULL wl_buffer is applied and the parent surface is mapped."
|
2016-03-29 13:54:18 +00:00
|
|
|
return d->subSurfaceIsMapped && !d->subSurface->parentSurface().isNull() && d->subSurface->parentSurface()->isMapped();
|
2016-03-29 10:05:05 +00:00
|
|
|
}
|
|
|
|
return d->current.buffer != nullptr;
|
|
|
|
}
|
|
|
|
|
2016-04-01 06:36:34 +00:00
|
|
|
QRegion SurfaceInterface::trackedDamage() const
|
|
|
|
{
|
|
|
|
return d->trackedDamage;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterface::resetTrackedDamage()
|
|
|
|
{
|
|
|
|
d->trackedDamage = QRegion();
|
|
|
|
}
|
|
|
|
|
2016-08-22 12:18:23 +00:00
|
|
|
QVector<OutputInterface *> SurfaceInterface::outputs() const
|
|
|
|
{
|
|
|
|
return d->outputs;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SurfaceInterface::setOutputs(const QVector<OutputInterface *> &outputs)
|
|
|
|
{
|
|
|
|
QVector<OutputInterface *> removedOutputs = d->outputs;
|
|
|
|
for (auto it = outputs.constBegin(), end = outputs.constEnd(); it != end; ++it) {
|
|
|
|
const auto o = *it;
|
|
|
|
removedOutputs.removeOne(o);
|
|
|
|
}
|
|
|
|
for (auto it = removedOutputs.constBegin(), end = removedOutputs.constEnd(); it != end; ++it) {
|
|
|
|
const auto resources = (*it)->clientResources(client());
|
2020-07-04 07:51:33 +00:00
|
|
|
for (wl_resource *outputResource : resources) {
|
|
|
|
d->send_leave(outputResource);
|
2016-08-22 12:18:23 +00:00
|
|
|
}
|
2017-08-26 10:53:09 +00:00
|
|
|
disconnect(d->outputDestroyedConnections.take(*it));
|
2016-08-22 12:18:23 +00:00
|
|
|
}
|
|
|
|
QVector<OutputInterface *> addedOutputsOutputs = outputs;
|
|
|
|
for (auto it = d->outputs.constBegin(), end = d->outputs.constEnd(); it != end; ++it) {
|
|
|
|
const auto o = *it;
|
|
|
|
addedOutputsOutputs.removeOne(o);
|
|
|
|
}
|
|
|
|
for (auto it = addedOutputsOutputs.constBegin(), end = addedOutputsOutputs.constEnd(); it != end; ++it) {
|
2017-08-26 10:53:09 +00:00
|
|
|
const auto o = *it;
|
|
|
|
const auto resources = o->clientResources(client());
|
2020-07-04 07:51:33 +00:00
|
|
|
for (wl_resource *outputResource : resources) {
|
|
|
|
d->send_enter(outputResource);
|
2016-08-22 12:18:23 +00:00
|
|
|
}
|
2017-08-26 10:53:09 +00:00
|
|
|
d->outputDestroyedConnections[o] = connect(o, &Global::aboutToDestroyGlobal, this, [this, o] {
|
|
|
|
auto outputs = d->outputs;
|
|
|
|
if (outputs.removeOne(o)) {
|
|
|
|
setOutputs(outputs);
|
|
|
|
}});
|
2016-08-22 12:18:23 +00:00
|
|
|
}
|
|
|
|
// TODO: send enter when the client binds the OutputInterface another time
|
|
|
|
|
|
|
|
d->outputs = outputs;
|
|
|
|
}
|
|
|
|
|
2016-04-05 12:26:53 +00:00
|
|
|
SurfaceInterface *SurfaceInterface::surfaceAt(const QPointF &position)
|
|
|
|
{
|
|
|
|
if (!isMapped()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
// go from top to bottom. Top most child is last in list
|
|
|
|
QListIterator<QPointer<SubSurfaceInterface>> it(d->current.children);
|
|
|
|
it.toBack();
|
|
|
|
while (it.hasPrevious()) {
|
|
|
|
const auto ¤t = it.previous();
|
|
|
|
auto surface = current->surface();
|
|
|
|
if (surface.isNull()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (auto s = surface->surfaceAt(position - current->position())) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// check whether the geometry contains the pos
|
|
|
|
if (!size().isEmpty() && QRectF(QPoint(0, 0), size()).contains(position)) {
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-10-02 16:11:52 +00:00
|
|
|
SurfaceInterface *SurfaceInterface::inputSurfaceAt(const QPointF &position)
|
|
|
|
{
|
|
|
|
// TODO: Most of this is very similar to SurfaceInterface::surfaceAt
|
|
|
|
// Is there a way to reduce the code duplication?
|
|
|
|
if (!isMapped()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
// go from top to bottom. Top most child is last in list
|
|
|
|
QListIterator<QPointer<SubSurfaceInterface>> it(d->current.children);
|
|
|
|
it.toBack();
|
|
|
|
while (it.hasPrevious()) {
|
|
|
|
const auto ¤t = it.previous();
|
|
|
|
auto surface = current->surface();
|
|
|
|
if (surface.isNull()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (auto s = surface->inputSurfaceAt(position - current->position())) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// check whether the geometry and input region contain the pos
|
|
|
|
if (!size().isEmpty() && QRectF(QPoint(0, 0), size()).contains(position) &&
|
|
|
|
(inputIsInfinite() || input().contains(position.toPoint()))) {
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-11-08 13:17:15 +00:00
|
|
|
QPointer<LockedPointerInterface> SurfaceInterface::lockedPointer() const
|
|
|
|
{
|
|
|
|
return d->lockedPointer;
|
|
|
|
}
|
|
|
|
|
|
|
|
QPointer<ConfinedPointerInterface> SurfaceInterface::confinedPointer() const
|
|
|
|
{
|
|
|
|
return d->confinedPointer;
|
|
|
|
}
|
|
|
|
|
2017-10-20 16:28:25 +00:00
|
|
|
bool SurfaceInterface::inhibitsIdle() const
|
|
|
|
{
|
|
|
|
return !d->idleInhibitors.isEmpty();
|
|
|
|
}
|
|
|
|
|
2019-02-06 08:26:43 +00:00
|
|
|
void SurfaceInterface::setDataProxy(SurfaceInterface *surface)
|
|
|
|
{
|
|
|
|
d->dataProxy = surface;
|
|
|
|
}
|
|
|
|
|
|
|
|
SurfaceInterface* SurfaceInterface::dataProxy() const
|
|
|
|
{
|
|
|
|
return d->dataProxy;
|
|
|
|
}
|
|
|
|
|
2020-05-23 18:12:36 +00:00
|
|
|
QPointF SurfaceInterface::mapToBuffer(const QPointF &point) const
|
|
|
|
{
|
2020-06-10 07:42:16 +00:00
|
|
|
return d->surfaceToBufferMatrix.map(point);
|
2020-05-23 18:12:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QPointF SurfaceInterface::mapFromBuffer(const QPointF &point) const
|
|
|
|
{
|
2020-06-10 07:42:16 +00:00
|
|
|
return d->bufferToSurfaceMatrix.map(point);
|
2020-05-23 18:12:36 +00:00
|
|
|
}
|
|
|
|
|
2020-06-10 07:42:16 +00:00
|
|
|
static QRegion map_helper(const QMatrix4x4 &matrix, const QRegion ®ion)
|
2020-05-23 18:12:36 +00:00
|
|
|
{
|
2020-06-10 07:42:16 +00:00
|
|
|
QRegion result;
|
|
|
|
for (const QRect &rect : region) {
|
|
|
|
result += matrix.mapRect(rect);
|
|
|
|
}
|
|
|
|
return result;
|
2020-05-23 18:12:36 +00:00
|
|
|
}
|
|
|
|
|
2020-06-10 07:42:16 +00:00
|
|
|
QRegion SurfaceInterface::mapToBuffer(const QRegion ®ion) const
|
2020-05-23 18:12:36 +00:00
|
|
|
{
|
2020-06-10 07:42:16 +00:00
|
|
|
return map_helper(d->surfaceToBufferMatrix, region);
|
2020-05-23 18:12:36 +00:00
|
|
|
}
|
|
|
|
|
2020-06-10 07:42:16 +00:00
|
|
|
QRegion SurfaceInterface::mapFromBuffer(const QRegion ®ion) const
|
2020-05-23 18:12:36 +00:00
|
|
|
{
|
2020-06-10 07:42:16 +00:00
|
|
|
return map_helper(d->bufferToSurfaceMatrix, region);
|
2020-05-23 18:12:36 +00:00
|
|
|
}
|
|
|
|
|
2020-06-10 07:42:16 +00:00
|
|
|
QMatrix4x4 SurfaceInterface::surfaceToBufferMatrix() const
|
2020-05-23 18:12:36 +00:00
|
|
|
{
|
2020-06-10 07:42:16 +00:00
|
|
|
return d->surfaceToBufferMatrix;
|
2020-05-23 18:12:36 +00:00
|
|
|
}
|
|
|
|
|
2020-07-04 07:51:33 +00:00
|
|
|
} // namespace KWaylandServer
|