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

215 lines
5.9 KiB
C++
Raw Normal View History

scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
/*
SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "surfaceitem_wayland.h"
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
#include "composite.h"
#include "scene.h"
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
wayland: Switch to ClientBuffer The main motivation behind the split is to simplify client buffer code and allow adding new features easier, for example referencing the shm pool when a shm buffer is destroyed, or monitoring for readable linux dmabuf file descriptors, etc. Also, a referenced ClientBuffer cannot be destroyed, unlike the old BufferInterface.
2021-07-20 19:37:03 +00:00
#include <KWaylandServer/clientbuffer.h>
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
#include <KWaylandServer/subcompositor_interface.h>
#include <KWaylandServer/surface_interface.h>
namespace KWin
{
SurfaceItemWayland::SurfaceItemWayland(KWaylandServer::SurfaceInterface *surface,
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
Toplevel *window, Item *parent)
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
: SurfaceItem(window, parent)
, m_surface(surface)
{
connect(surface, &KWaylandServer::SurfaceInterface::surfaceToBufferMatrixChanged,
wayland: Cache last surface-to-buffer matrix If window quads need to be generated after the wl_surface is destroyed, the SurfaceItemWayland::mapToBuffer() function will return wrong values. In order to fix that, we need to store the last surface-to-buffer matrix in SurfaceItem.
2021-07-21 19:25:42 +00:00
this, &SurfaceItemWayland::handleSurfaceToBufferMatrixChanged);
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
connect(surface, &KWaylandServer::SurfaceInterface::sizeChanged,
this, &SurfaceItemWayland::handleSurfaceSizeChanged);
connect(surface, &KWaylandServer::SurfaceInterface::bufferSizeChanged,
this, &SurfaceItemWayland::discardPixmap);
connect(surface, &KWaylandServer::SurfaceInterface::childSubSurfacesChanged,
this, &SurfaceItemWayland::handleChildSubSurfacesChanged);
connect(surface, &KWaylandServer::SurfaceInterface::committed,
this, &SurfaceItemWayland::handleSurfaceCommitted);
connect(surface, &KWaylandServer::SurfaceInterface::damaged,
this, &SurfaceItemWayland::addDamage);
connect(surface, &KWaylandServer::SurfaceInterface::childSubSurfaceRemoved,
this, &SurfaceItemWayland::handleChildSubSurfaceRemoved);
KWaylandServer::SubSurfaceInterface *subsurface = surface->subSurface();
if (subsurface) {
wayland: Wire in surface mapped state If a sub-surface should be considered unmapped, make the corresponding item invisible. Note that this must apply only to sub-surfaces. Whether the main surface should be visible is up to kwin. It may want to play an animation when the toplevel surface is unmapped, etc.
2021-07-28 17:08:48 +00:00
connect(surface, &KWaylandServer::SurfaceInterface::mapped,
this, &SurfaceItemWayland::handleSubSurfaceMappedChanged);
connect(surface, &KWaylandServer::SurfaceInterface::unmapped,
this, &SurfaceItemWayland::handleSubSurfaceMappedChanged);
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
connect(subsurface, &KWaylandServer::SubSurfaceInterface::positionChanged,
this, &SurfaceItemWayland::handleSubSurfacePositionChanged);
wayland: Wire in surface mapped state If a sub-surface should be considered unmapped, make the corresponding item invisible. Note that this must apply only to sub-surfaces. Whether the main surface should be visible is up to kwin. It may want to play an animation when the toplevel surface is unmapped, etc.
2021-07-28 17:08:48 +00:00
setVisible(surface->isMapped());
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
setPosition(subsurface->position());
}
wayland: Allow placing sub-surfaces below their parent According to the spec, if the wl_subsurface.place_below request is called with the parent surface, the sub-surface must be placed below the parent surface. BUG: 438808
2021-06-19 14:01:12 +00:00
handleChildSubSurfacesChanged();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
setSize(surface->size());
wayland: Cache last surface-to-buffer matrix If window quads need to be generated after the wl_surface is destroyed, the SurfaceItemWayland::mapToBuffer() function will return wrong values. In order to fix that, we need to store the last surface-to-buffer matrix in SurfaceItem.
2021-07-21 19:25:42 +00:00
setSurfaceToBufferMatrix(surface->surfaceToBufferMatrix());
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
QRegion SurfaceItemWayland::shape() const
{
Remove unused geometry setters in Item Originally, only x, y, width, and height property setters were used. A bit later "position" and "size" helper setters were added to simplify code in SurfaceItem sub-classes. It seems like setX(), setY(), setWidth(), and setHeight() are unused now, so remove them.
2021-07-05 17:40:47 +00:00
return QRegion(rect());
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
QRegion SurfaceItemWayland::opaque() const
{
if (m_surface) {
return m_surface->opaque();
}
return QRegion();
}
KWaylandServer::SurfaceInterface *SurfaceItemWayland::surface() const
{
return m_surface;
}
wayland: Cache last surface-to-buffer matrix If window quads need to be generated after the wl_surface is destroyed, the SurfaceItemWayland::mapToBuffer() function will return wrong values. In order to fix that, we need to store the last surface-to-buffer matrix in SurfaceItem.
2021-07-21 19:25:42 +00:00
void SurfaceItemWayland::handleSurfaceToBufferMatrixChanged()
{
setSurfaceToBufferMatrix(m_surface->surfaceToBufferMatrix());
discardQuads();
discardPixmap();
}
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
void SurfaceItemWayland::handleSurfaceSizeChanged()
{
setSize(m_surface->size());
}
void SurfaceItemWayland::handleSurfaceCommitted()
{
if (m_surface->hasFrameCallbacks()) {
Rename Item::scheduleRepaint() One can think that Item::scheduleRepaint() will trigger repaint of the whole item, but it actually only schedules the next frame. If nothing has changed on the screen, no real painting will be done unless maybe if the rendering backend needs to repair the back buffer.
2021-05-19 06:35:42 +00:00
scheduleFrame();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
}
wayland: Allow placing sub-surfaces below their parent According to the spec, if the wl_subsurface.place_below request is called with the parent surface, the sub-surface must be placed below the parent surface. BUG: 438808
2021-06-19 14:01:12 +00:00
SurfaceItemWayland *SurfaceItemWayland::getOrCreateSubSurfaceItem(KWaylandServer::SubSurfaceInterface *child)
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
{
wayland: Allow placing sub-surfaces below their parent According to the spec, if the wl_subsurface.place_below request is called with the parent surface, the sub-surface must be placed below the parent surface. BUG: 438808
2021-06-19 14:01:12 +00:00
SurfaceItemWayland *&item = m_subsurfaces[child];
if (!item) {
item = new SurfaceItemWayland(child->surface(), window());
item->setParent(this);
item->setParentItem(this);
}
return item;
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
void SurfaceItemWayland::handleChildSubSurfaceRemoved(KWaylandServer::SubSurfaceInterface *child)
{
delete m_subsurfaces.take(child);
}
void SurfaceItemWayland::handleChildSubSurfacesChanged()
{
wayland: Switch to SurfaceInterface::{below,above}
2021-06-19 12:59:07 +00:00
const QList<KWaylandServer::SubSurfaceInterface *> below = m_surface->below();
const QList<KWaylandServer::SubSurfaceInterface *> above = m_surface->above();
wayland: Allow placing sub-surfaces below their parent According to the spec, if the wl_subsurface.place_below request is called with the parent surface, the sub-surface must be placed below the parent surface. BUG: 438808
2021-06-19 14:01:12 +00:00
for (int i = 0; i < below.count(); ++i) {
SurfaceItemWayland *subsurfaceItem = getOrCreateSubSurfaceItem(below[i]);
subsurfaceItem->setZ(i - below.count());
wayland: Switch to SurfaceInterface::{below,above}
2021-06-19 12:59:07 +00:00
}
wayland: Switch to ClientBuffer The main motivation behind the split is to simplify client buffer code and allow adding new features easier, for example referencing the shm pool when a shm buffer is destroyed, or monitoring for readable linux dmabuf file descriptors, etc. Also, a referenced ClientBuffer cannot be destroyed, unlike the old BufferInterface.
2021-07-20 19:37:03 +00:00
wayland: Allow placing sub-surfaces below their parent According to the spec, if the wl_subsurface.place_below request is called with the parent surface, the sub-surface must be placed below the parent surface. BUG: 438808
2021-06-19 14:01:12 +00:00
for (int i = 0; i < above.count(); ++i) {
SurfaceItemWayland *subsurfaceItem = getOrCreateSubSurfaceItem(above[i]);
subsurfaceItem->setZ(i);
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
}
void SurfaceItemWayland::handleSubSurfacePositionChanged()
{
setPosition(m_surface->subSurface()->position());
}
wayland: Wire in surface mapped state If a sub-surface should be considered unmapped, make the corresponding item invisible. Note that this must apply only to sub-surfaces. Whether the main surface should be visible is up to kwin. It may want to play an animation when the toplevel surface is unmapped, etc.
2021-07-28 17:08:48 +00:00
void SurfaceItemWayland::handleSubSurfaceMappedChanged()
{
setVisible(m_surface->isMapped());
}
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
SurfacePixmap *SurfaceItemWayland::createPixmap()
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
return new SurfacePixmapWayland(this);
}
SurfacePixmapWayland::SurfacePixmapWayland(SurfaceItemWayland *item, QObject *parent)
: SurfacePixmap(Compositor::self()->scene()->createPlatformSurfaceTextureWayland(this), parent)
, m_item(item)
{
}
SurfacePixmapWayland::~SurfacePixmapWayland()
{
setBuffer(nullptr);
}
wayland: Cache last surface-to-buffer matrix If window quads need to be generated after the wl_surface is destroyed, the SurfaceItemWayland::mapToBuffer() function will return wrong values. In order to fix that, we need to store the last surface-to-buffer matrix in SurfaceItem.
2021-07-21 19:25:42 +00:00
SurfaceItemWayland *SurfacePixmapWayland::item() const
{
return m_item;
}
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
KWaylandServer::SurfaceInterface *SurfacePixmapWayland::surface() const
{
return m_item->surface();
}
wayland: Switch to ClientBuffer The main motivation behind the split is to simplify client buffer code and allow adding new features easier, for example referencing the shm pool when a shm buffer is destroyed, or monitoring for readable linux dmabuf file descriptors, etc. Also, a referenced ClientBuffer cannot be destroyed, unlike the old BufferInterface.
2021-07-20 19:37:03 +00:00
KWaylandServer::ClientBuffer *SurfacePixmapWayland::buffer() const
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
{
return m_buffer;
}
void SurfacePixmapWayland::create()
{
update();
}
void SurfacePixmapWayland::update()
{
KWaylandServer::SurfaceInterface *surface = m_item->surface();
if (surface) {
setBuffer(surface->buffer());
}
}
bool SurfacePixmapWayland::isValid() const
{
wayland: Switch to ClientBuffer The main motivation behind the split is to simplify client buffer code and allow adding new features easier, for example referencing the shm pool when a shm buffer is destroyed, or monitoring for readable linux dmabuf file descriptors, etc. Also, a referenced ClientBuffer cannot be destroyed, unlike the old BufferInterface.
2021-07-20 19:37:03 +00:00
return m_buffer;
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
}
wayland: Switch to ClientBuffer The main motivation behind the split is to simplify client buffer code and allow adding new features easier, for example referencing the shm pool when a shm buffer is destroyed, or monitoring for readable linux dmabuf file descriptors, etc. Also, a referenced ClientBuffer cannot be destroyed, unlike the old BufferInterface.
2021-07-20 19:37:03 +00:00
void SurfacePixmapWayland::setBuffer(KWaylandServer::ClientBuffer *buffer)
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
{
if (m_buffer == buffer) {
return;
}
if (m_buffer) {
m_buffer->unref();
}
m_buffer = buffer;
if (m_buffer) {
m_buffer->ref();
m_hasAlphaChannel = m_buffer->hasAlphaChannel();
}
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
SurfaceItemXwayland::SurfaceItemXwayland(Toplevel *window, Item *parent)
: SurfaceItemWayland(window->surface(), window, parent)
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
{
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
connect(window, &Toplevel::geometryShapeChanged, this, &SurfaceItemXwayland::discardQuads);
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
QRegion SurfaceItemXwayland::shape() const
{
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
const QRect clipRect = rect() & window()->clientGeometry().translated(-window()->bufferGeometry().topLeft());
const QRegion shape = window()->shapeRegion();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
return shape & clipRect;
}
} // namespace KWin
Reference in a new issue Copy permalink