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

383 lines
8.4 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 "item.h"
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
#include "abstract_output.h"
#include "composite.h"
#include "main.h"
#include "platform.h"
#include "renderloop.h"
Move all dirty region scene repaint scheduling to Scene The Compositor contains nothing that can potentially get dirty and need repainting. As is, the advantages of this move aren't really noticeable, but it makes sense with multiple scenes. Backend parts are far from ideal, they can be improved later on as we progress with the scene redesign.
2021-11-09 10:36:24 +00:00
#include "scene.h"
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
#include "screens.h"
Move utils.h file to utils directory
2022-01-18 08:35:52 +00:00
#include "utils/common.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
namespace KWin
{
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
Item::Item(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
{
setParentItem(parent);
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
connect(kwinApp()->platform(), &Platform::outputDisabled, this, &Item::removeRepaints);
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
}
Item::~Item()
{
setParentItem(nullptr);
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
for (const auto &dirty : qAsConst(m_repaints)) {
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
if (!dirty.isEmpty()) {
Move all dirty region scene repaint scheduling to Scene The Compositor contains nothing that can potentially get dirty and need repainting. As is, the advantages of this move aren't really noticeable, but it makes sense with multiple scenes. Backend parts are far from ideal, they can be improved later on as we progress with the scene redesign.
2021-11-09 10:36:24 +00:00
Compositor::self()->scene()->addRepaint(dirty);
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
}
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
}
scene: Introduce z-property This allows placing child items below their parent item by setting negative Z values.
2021-06-19 14:00:19 +00:00
int Item::z() const
{
return m_z;
}
void Item::setZ(int z)
{
if (m_z == z) {
return;
}
m_z = z;
if (m_parentItem) {
m_parentItem->markSortedChildItemsDirty();
}
scheduleRepaint(boundingRect());
}
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
Item *Item::parentItem() const
{
return m_parentItem;
}
void Item::setParentItem(Item *item)
{
if (m_parentItem == item) {
return;
}
if (m_parentItem) {
m_parentItem->removeChild(this);
}
m_parentItem = item;
if (m_parentItem) {
m_parentItem->addChild(this);
}
Introduce Item visible property This property can be used to control the visibility of an item and its child subtree.
2021-05-26 09:27:27 +00:00
updateEffectiveVisibility();
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 Item::addChild(Item *item)
{
Q_ASSERT(!m_childItems.contains(item));
m_childItems.append(item);
scene: Introduce z-property This allows placing child items below their parent item by setting negative Z values.
2021-06-19 14:00:19 +00:00
markSortedChildItemsDirty();
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
updateBoundingRect();
scheduleRepaint(item->boundingRect().translated(item->position()));
}
void Item::removeChild(Item *item)
{
Q_ASSERT(m_childItems.contains(item));
scheduleRepaint(item->boundingRect().translated(item->position()));
m_childItems.removeOne(item);
scene: Introduce z-property This allows placing child items below their parent item by setting negative Z values.
2021-06-19 14:00:19 +00:00
markSortedChildItemsDirty();
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
updateBoundingRect();
}
QList<Item *> Item::childItems() const
{
return m_childItems;
}
QPoint Item::position() 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 m_position;
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 Item::setPosition(const QPoint &point)
{
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
if (m_position != point) {
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
scheduleRepaint(boundingRect());
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
m_position = point;
Properly update parent item's bounding rect when moving item The bounding rect of an item is in the item-local coordinate space. If the item is moved, its bounding rect won't change, but the parent's bounding rect, may change. BUG: 443756
2021-10-15 07:29:35 +00:00
if (m_parentItem) {
m_parentItem->updateBoundingRect();
}
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
scheduleRepaint(boundingRect());
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
Q_EMIT positionChanged();
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
}
}
QSize Item::size() 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 m_size;
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 Item::setSize(const QSize &size)
{
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
if (m_size != size) {
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
scheduleRepaint(rect());
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
m_size = size;
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
updateBoundingRect();
scheduleRepaint(rect());
discardQuads();
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
Q_EMIT sizeChanged();
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
}
}
QRect Item::rect() const
{
return QRect(QPoint(0, 0), size());
}
QRect Item::boundingRect() const
{
return m_boundingRect;
}
void Item::updateBoundingRect()
{
QRect boundingRect = rect();
for (Item *item : qAsConst(m_childItems)) {
boundingRect |= item->boundingRect().translated(item->position());
}
if (m_boundingRect != boundingRect) {
m_boundingRect = boundingRect;
Run clazy with qt-keywords fixit In C++20, there will be emit() class member, which can conflict with the emit keyword. Given that, there are plans to enable QT_NO_KEYWORDS by default in the future. See also https://lists.qt-project.org/pipermail/development/2020-February/038812.html
2021-06-08 07:02:14 +00:00
Q_EMIT boundingRectChanged();
Update parent item's bounding rect explicitly If the parent's bounding rect may change, call its update method explicitly. This way the code is more readable as there is less signal-slot magic.
2021-07-05 17:32:03 +00:00
if (m_parentItem) {
m_parentItem->updateBoundingRect();
}
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
}
}
QPoint Item::rootPosition() const
{
QPoint ret = position();
Item *parent = parentItem();
while (parent) {
ret += parent->position();
parent = parent->parentItem();
}
return ret;
}
scenes/opengl: Calculate item transforms differently Currently, a vertex coordinate is transformed first, then mapped to the global screen coordinates. This causes a problem if a transform is applied to the top-most item and child items are not at (0, 0). For example, scaled windows may have popping out sub-surfaces, etc. With this change, the item transforms will be computed differently. For example, if the parent item is transformed, a child's transform will look as follows [Parent's translation][Parent's transform][Child's translation] instead of [Parent's translation][Child's translation][Parent's transform] In the future, I'd like to get rid of the Item::setTransform() call in OpenGLWindow::performPaint() and have either AnimationEffect or libkwineffects call Item::setTransform(). BUG: 440201
2021-08-11 15:03:06 +00:00
QMatrix4x4 Item::transform() const
{
return m_transform;
}
void Item::setTransform(const QMatrix4x4 &transform)
{
m_transform = transform;
}
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 Item::mapToGlobal(const QRegion &region) const
{
return region.translated(rootPosition());
}
QRect Item::mapToGlobal(const QRect &rect) const
{
return rect.translated(rootPosition());
}
void Item::stackBefore(Item *sibling)
{
if (Q_UNLIKELY(!sibling)) {
qCDebug(KWIN_CORE) << Q_FUNC_INFO << "requires a valid sibling";
return;
}
if (Q_UNLIKELY(!sibling->parentItem() || sibling->parentItem() != parentItem())) {
qCDebug(KWIN_CORE) << Q_FUNC_INFO << "requires items to be siblings";
return;
}
if (Q_UNLIKELY(sibling == this)) {
return;
}
const int selfIndex = m_parentItem->m_childItems.indexOf(this);
const int siblingIndex = m_parentItem->m_childItems.indexOf(sibling);
if (selfIndex == siblingIndex - 1) {
return;
}
m_parentItem->m_childItems.move(selfIndex, selfIndex > siblingIndex ? siblingIndex : siblingIndex - 1);
scene: Introduce z-property This allows placing child items below their parent item by setting negative Z values.
2021-06-19 14:00:19 +00:00
markSortedChildItemsDirty();
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
scheduleRepaint(boundingRect());
sibling->scheduleRepaint(sibling->boundingRect());
}
void Item::stackAfter(Item *sibling)
{
if (Q_UNLIKELY(!sibling)) {
qCDebug(KWIN_CORE) << Q_FUNC_INFO << "requires a valid sibling";
return;
}
if (Q_UNLIKELY(!sibling->parentItem() || sibling->parentItem() != parentItem())) {
qCDebug(KWIN_CORE) << Q_FUNC_INFO << "requires items to be siblings";
return;
}
if (Q_UNLIKELY(sibling == this)) {
return;
}
const int selfIndex = m_parentItem->m_childItems.indexOf(this);
const int siblingIndex = m_parentItem->m_childItems.indexOf(sibling);
if (selfIndex == siblingIndex + 1) {
return;
}
m_parentItem->m_childItems.move(selfIndex, selfIndex > siblingIndex ? siblingIndex + 1 : siblingIndex);
scene: Introduce z-property This allows placing child items below their parent item by setting negative Z values.
2021-06-19 14:00:19 +00:00
markSortedChildItemsDirty();
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
scheduleRepaint(boundingRect());
sibling->scheduleRepaint(sibling->boundingRect());
}
void Item::scheduleRepaint(const QRegion &region)
Introduce Item visible property This property can be used to control the visibility of an item and its child subtree.
2021-05-26 09:27:27 +00:00
{
if (isVisible()) {
scheduleRepaintInternal(region);
}
}
void Item::scheduleRepaintInternal(const QRegion &region)
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
{
Drop Platform::renderLoop() Having a render loop in the Platform has always been awkward. Another way to interpret the platform not supporting per screen rendering would be that all outputs share the same render loop. On X11, Scene::painted_screen is going to correspond to the primary screen, we should not rely on this assumption though!
2022-02-05 13:20:17 +00:00
const QVector<AbstractOutput *> outputs = kwinApp()->platform()->enabledOutputs();
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
const QRegion globalRegion = mapToGlobal(region);
Drop Platform::isPerScreenRenderingEnabled() At this point, it's safe to assume that only X11 has weird rendering model, which stands in the way of making rendering abstractions nice and intuitive, so let's check operation mode. If OperationModeX11 is dropped, this will also simplify finding X11-specific code in kwin.
2022-02-17 14:53:12 +00:00
if (kwinApp()->operationMode() != Application::OperationModeX11) {
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
for (const auto &output : outputs) {
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
const QRegion dirtyRegion = globalRegion & output->geometry();
if (!dirtyRegion.isEmpty()) {
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
m_repaints[output] += dirtyRegion;
RenderLoop: restrict repaint scheduling with fullscreen windows With an opaque fullscreen window we can be sure that items under it don't actually require us to repaint. This should yield some small efficiency improvements and resolves stutter with adaptive sync. BUG: 443872 FIXED-IN: 5.23.3
2021-11-04 16:34:17 +00:00
output->renderLoop()->scheduleRepaint(this);
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
}
} else {
Drop Platform::renderLoop() Having a render loop in the Platform has always been awkward. Another way to interpret the platform not supporting per screen rendering would be that all outputs share the same render loop. On X11, Scene::painted_screen is going to correspond to the primary screen, we should not rely on this assumption though!
2022-02-05 13:20:17 +00:00
m_repaints[outputs.constFirst()] += globalRegion;
outputs.constFirst()->renderLoop()->scheduleRepaint(this);
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
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
}
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
void Item::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
{
Introduce Item visible property This property can be used to control the visibility of an item and its child subtree.
2021-05-26 09:27:27 +00:00
if (!isVisible()) {
return;
}
Drop Platform::renderLoop() Having a render loop in the Platform has always been awkward. Another way to interpret the platform not supporting per screen rendering would be that all outputs share the same render loop. On X11, Scene::painted_screen is going to correspond to the primary screen, we should not rely on this assumption though!
2022-02-05 13:20:17 +00:00
const QVector<AbstractOutput *> outputs = kwinApp()->platform()->enabledOutputs();
Drop Platform::isPerScreenRenderingEnabled() At this point, it's safe to assume that only X11 has weird rendering model, which stands in the way of making rendering abstractions nice and intuitive, so let's check operation mode. If OperationModeX11 is dropped, this will also simplify finding X11-specific code in kwin.
2022-02-17 14:53:12 +00:00
if (kwinApp()->operationMode() != Application::OperationModeX11) {
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
const QRect geometry = mapToGlobal(rect());
for (const AbstractOutput *output : outputs) {
if (output->geometry().intersects(geometry)) {
RenderLoop: restrict repaint scheduling with fullscreen windows With an opaque fullscreen window we can be sure that items under it don't actually require us to repaint. This should yield some small efficiency improvements and resolves stutter with adaptive sync. BUG: 443872 FIXED-IN: 5.23.3
2021-11-04 16:34:17 +00:00
output->renderLoop()->scheduleRepaint(this);
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
}
} else {
Drop Platform::renderLoop() Having a render loop in the Platform has always been awkward. Another way to interpret the platform not supporting per screen rendering would be that all outputs share the same render loop. On X11, Scene::painted_screen is going to correspond to the primary screen, we should not rely on this assumption though!
2022-02-05 13:20:17 +00:00
outputs.constFirst()->renderLoop()->scheduleRepaint(this);
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
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 Item::preprocess()
{
}
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
WindowQuadList Item::buildQuads() const
{
return WindowQuadList();
}
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 Item::discardQuads()
{
scene: Store cached quads using std::optional This way, the code is slightly more readable.
2021-06-19 17:50:19 +00:00
m_quads.reset();
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
}
WindowQuadList Item::quads() const
{
scene: Store cached quads using std::optional This way, the code is slightly more readable.
2021-06-19 17:50:19 +00:00
if (!m_quads.has_value()) {
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
m_quads = buildQuads();
}
scene: Store cached quads using std::optional This way, the code is slightly more readable.
2021-06-19 17:50:19 +00:00
return m_quads.value();
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
}
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
QRegion Item::repaints(AbstractOutput *output) const
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
{
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
return m_repaints.value(output, QRect(QPoint(0, 0), screens()->size()));
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
void Item::resetRepaints(AbstractOutput *output)
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
{
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
m_repaints.insert(output, QRegion());
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
void Item::removeRepaints(AbstractOutput *output)
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
{
Port screenId based rendering methods to AbstractOutput
2021-08-24 20:55:42 +00:00
m_repaints.remove(output);
Move repaint scheduling logic to Item Currently, items depend on scene windows for creating pixmaps, repaint scheduling, and caching quads. This change moves repaint scheduling from scene windows to items to make the scene items depend less on scene windows. In hindsight, we may clean up the repaint scheduling machinery further by introducing view objects.
2021-04-30 08:42:54 +00:00
}
Introduce Item visible property This property can be used to control the visibility of an item and its child subtree.
2021-05-26 09:27:27 +00:00
bool Item::isVisible() const
{
return m_effectiveVisible;
}
void Item::setVisible(bool visible)
{
if (m_visible != visible) {
m_visible = visible;
updateEffectiveVisibility();
}
}
bool Item::computeEffectiveVisibility() const
{
return m_visible && (!m_parentItem || m_parentItem->isVisible());
}
void Item::updateEffectiveVisibility()
{
const bool effectiveVisible = computeEffectiveVisibility();
if (m_effectiveVisible == effectiveVisible) {
return;
}
m_effectiveVisible = effectiveVisible;
scheduleRepaintInternal(boundingRect());
for (Item *childItem : qAsConst(m_childItems)) {
childItem->updateEffectiveVisibility();
}
}
scene: Introduce z-property This allows placing child items below their parent item by setting negative Z values.
2021-06-19 14:00:19 +00:00
static bool compareZ(const Item *a, const Item *b)
{
return a->z() < b->z();
}
QList<Item *> Item::sortedChildItems() const
{
if (!m_sortedChildItems.has_value()) {
QList<Item *> items = m_childItems;
std::stable_sort(items.begin(), items.end(), compareZ);
m_sortedChildItems = items;
}
return m_sortedChildItems.value();
}
void Item::markSortedChildItemsDirty()
{
m_sortedChildItems.reset();
}
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
} // namespace KWin
Reference in a new issue Copy permalink