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

Move decoration pixmap handling from Client to PaintRedirector

Browse source 
The only task of the PaintRedirector is to redirect the painting of the
window decorations into Pixmaps. So it should actually do this by also
handling the four pixmaps for the decoration. This simplifies the code
as all the logic concerning redirecting the painting is now grouped
together.

Furthermore the PaintRedirector is now a child of the decoration widget,
which means it gets automatically destroyed whenever the decoration is
destroyed - the Client does not have to care about it.

Also the PaintRedirector gets only created if the Compositor is active as
it is not needed in the non-compositing case.

REVIEW: 106620
This commit is contained in:
Martin Gräßlin 2012-09-28 11:59:42 +02:00
parent c129dc2d63
commit 0d81d1d7c0
8 changed files with 208 additions and 244 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

181
client.cpp
View file

@ -124,7 +124,6 @@ Client::Client(Workspace* ws)
, padding_bottom(0)
, sm_stacking_order(-1)
, demandAttentionKNotifyTimer(NULL)
, m_responsibleForDecoPixmap(false)
, paintRedirector(0)
, m_firstInTabBox(false)
, electricMaximizing(false)
@ -414,11 +413,10 @@ void Client::updateDecoration(bool check_workspace_pos, bool force)
XMoveWindow(display(), decoration->widget()->winId(), -padding_left, -padding_top);
move(calculateGravitation(false));
plainResize(sizeForClientSize(clientSize()), ForceGeometrySet);
paintRedirector = new PaintRedirector(decoration->widget());
connect(paintRedirector, SIGNAL(paintPending()), SLOT(repaintDecorationPending()));
resizeDecorationPixmaps();
if (compositing())
if (Compositor::compositing()) {
paintRedirector = new PaintRedirector(this, decoration->widget());
discardWindowPixmap();
}
emit geometryShapeChanged(this, oldgeom);
} else
destroyDecoration();
@ -437,21 +435,12 @@ void Client::destroyDecoration()
if (decoration != NULL) {
delete decoration;
decoration = NULL;
paintRedirector = NULL;
QPoint grav = calculateGravitation(true);
border_left = border_right = border_top = border_bottom = 0;
setMask(QRegion()); // Reset shape mask
plainResize(sizeForClientSize(clientSize()), ForceGeometrySet);
move(grav);
delete paintRedirector;
paintRedirector = NULL;
if (m_responsibleForDecoPixmap) {
XFreePixmap(display(), decorationPixmapTop.handle());
XFreePixmap(display(), decorationPixmapBottom.handle());
XFreePixmap(display(), decorationPixmapLeft.handle());
XFreePixmap(display(), decorationPixmapRight.handle());
m_responsibleForDecoPixmap = false;
}
decorationPixmapLeft = decorationPixmapRight = decorationPixmapTop = decorationPixmapBottom = QPixmap();
if (compositing())
discardWindowPixmap();
if (!deleting) {
@ -543,162 +532,6 @@ QRegion Client::decorationPendingRegion() const
return paintRedirector->scheduledRepaintRegion().translated(x() - padding_left, y() - padding_top);
}
void Client::repaintDecorationPending()
{
if (compositing()) {
// The scene will update the decoration pixmaps in the next painting pass
// if it has not been already repainted before
const QRegion r = paintRedirector->scheduledRepaintRegion();
if (!r.isEmpty()) {
addRepaint(r.translated(-padding_left,-padding_top));
}
}
}
bool Client::decorationPixmapRequiresRepaint()
{
if (!paintRedirector)
return false;
QRegion r = paintRedirector->pendingRegion();
return !r.isEmpty();
}
void Client::ensureDecorationPixmapsPainted()
{
if (!paintRedirector || !compositing())
return;
QRegion r = paintRedirector->pendingRegion();
if (r.isEmpty())
return;
QPixmap p = paintRedirector->performPendingPaint();
QRect lr, rr, tr, br;
layoutDecorationRects(lr, tr, rr, br, DecorationRelative);
repaintDecorationPixmap(decorationPixmapLeft, lr, p, r);
repaintDecorationPixmap(decorationPixmapRight, rr, p, r);
repaintDecorationPixmap(decorationPixmapTop, tr, p, r);
repaintDecorationPixmap(decorationPixmapBottom, br, p, r);
XSync(display(), false);
}
void Client::repaintDecorationPixmap(QPixmap& pix, const QRect& r, const QPixmap& src, QRegion reg)
{
if (!r.isValid())
return;
QRect b = reg.boundingRect();
reg &= r;
if (reg.isEmpty())
return;
QPainter pt(&pix);
pt.translate(-r.topLeft());
pt.setCompositionMode(QPainter::CompositionMode_Source);
pt.setClipRegion(reg);
pt.drawPixmap(b.topLeft(), src);
pt.end();
}
void Client::resizeDecorationPixmaps()
{
if (!compositing()) {
// compositing disabled - we render directly on screen
triggerDecorationRepaint();
return;
}
QRect lr, rr, tr, br;
layoutDecorationRects(lr, tr, rr, br, DecorationRelative);
if (decorationPixmapTop.size() != tr.size()) {
if (m_responsibleForDecoPixmap && !decorationPixmapTop.isNull() &&
decorationPixmapTop.paintEngine()->type() == QPaintEngine::X11) {
XFreePixmap(display(), decorationPixmapTop.handle());
}
if (effects->isOpenGLCompositing()) {
decorationPixmapTop = QPixmap(tr.size());
m_responsibleForDecoPixmap = false;
} else {
Pixmap xpix = XCreatePixmap(QX11Info::display(), rootWindow(),
tr.size().width(), tr.height(),
32);
decorationPixmapTop = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
decorationPixmapTop.fill(Qt::transparent);
m_responsibleForDecoPixmap= true;
}
}
if (decorationPixmapBottom.size() != br.size()) {
if (m_responsibleForDecoPixmap && !decorationPixmapBottom.isNull() &&
decorationPixmapBottom.paintEngine()->type() == QPaintEngine::X11) {
XFreePixmap(display(), decorationPixmapBottom.handle());
}
if (effects->isOpenGLCompositing()) {
decorationPixmapBottom = QPixmap(br.size());
m_responsibleForDecoPixmap = false;
} else {
Pixmap xpix = XCreatePixmap(QX11Info::display(), rootWindow(),
br.size().width(), br.height(),
32);
decorationPixmapBottom = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
decorationPixmapBottom.fill(Qt::transparent);
m_responsibleForDecoPixmap = true;
}
}
if (decorationPixmapLeft.size() != lr.size()) {
if (m_responsibleForDecoPixmap && !decorationPixmapLeft.isNull() &&
decorationPixmapLeft.paintEngine()->type() == QPaintEngine::X11) {
XFreePixmap(display(), decorationPixmapLeft.handle());
}
if (effects->isOpenGLCompositing()) {
decorationPixmapLeft = QPixmap(lr.size());
m_responsibleForDecoPixmap = false;
} else {
Pixmap xpix = XCreatePixmap(QX11Info::display(), rootWindow(),
lr.size().width(), lr.height(),
32);
decorationPixmapLeft = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
decorationPixmapLeft.fill(Qt::transparent);
m_responsibleForDecoPixmap = true;
}
}
if (decorationPixmapRight.size() != rr.size()) {
if (m_responsibleForDecoPixmap && !decorationPixmapRight.isNull() &&
decorationPixmapRight.paintEngine()->type() == QPaintEngine::X11) {
XFreePixmap(display(), decorationPixmapRight.handle());
}
if (effects->isOpenGLCompositing()) {
decorationPixmapRight = QPixmap(rr.size());
m_responsibleForDecoPixmap = false;
} else {
Pixmap xpix = XCreatePixmap(QX11Info::display(), rootWindow(),
rr.size().width(), rr.height(),
32);
decorationPixmapRight = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
decorationPixmapRight.fill(Qt::transparent);
m_responsibleForDecoPixmap = true;
}
}
#ifdef HAVE_XRENDER
if (Extensions::renderAvailable()) {
// Make sure the pixmaps are created with alpha channels
decorationPixmapLeft.fill(Qt::transparent);
decorationPixmapRight.fill(Qt::transparent);
decorationPixmapTop.fill(Qt::transparent);
decorationPixmapBottom.fill(Qt::transparent);
}
#endif
triggerDecorationRepaint();
}
QRect Client::transparentRect() const
{
if (isShade())
@ -781,8 +614,10 @@ void Client::resizeDecoration(const QSize& s)
if (oldSize == newSize) {
QResizeEvent e(newSize, oldSize);
QApplication::sendEvent(decoration->widget(), &e);
} else { // oldSize != newSize
resizeDecorationPixmaps();
} else if (paintRedirector) { // oldSize != newSize
paintRedirector->resizePixmaps();
} else {
triggerDecorationRepaint();
}
updateInputWindow();
}

22
client.h
View file

@ -584,17 +584,8 @@ public:
}
// Decorations <-> Effects
const QPixmap *topDecoPixmap() const {
return &decorationPixmapTop;
}
const QPixmap *leftDecoPixmap() const {
return &decorationPixmapLeft;
}
const QPixmap *bottomDecoPixmap() const {
return &decorationPixmapBottom;
}
const QPixmap *rightDecoPixmap() const {
return &decorationPixmapRight;
PaintRedirector *decorationPaintRedirector() {
return paintRedirector;
}
int paddingLeft() const {
@ -610,9 +601,6 @@ public:
return padding_bottom;
}
bool decorationPixmapRequiresRepaint();
void ensureDecorationPixmapsPainted();
QRect decorationRect() const;
QRect transparentRect() const;
@ -694,7 +682,6 @@ private slots:
void removeSyncSupport();
void pingTimeout();
void demandAttentionKNotify();
void repaintDecorationPending();
//Signals for the scripting interface
//Signals make an excellent way for communication
@ -795,8 +782,6 @@ private:
void updateHiddenPreview();
void updateInputShape();
void repaintDecorationPixmap(QPixmap& pix, const QRect& r, const QPixmap& src, QRegion reg);
void resizeDecorationPixmaps();
Time readUserTimeMapTimestamp(const KStartupInfoId* asn_id, const KStartupInfoData* asn_data,
bool session) const;
@ -947,9 +932,6 @@ private:
friend struct ResetupRulesProcedure;
friend class GeometryUpdatesBlocker;
QTimer* demandAttentionKNotifyTimer;
QPixmap decorationPixmapLeft, decorationPixmapRight, decorationPixmapTop, decorationPixmapBottom;
// we (instead of Qt) initialize the Pixmaps, and have to free them
bool m_responsibleForDecoPixmap;
PaintRedirector* paintRedirector;
QSharedPointer<TabBox::TabBoxClientImpl> m_tabBoxClient;
bool m_firstInTabBox;

11
deleted.cpp
View file

@ -22,6 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "workspace.h"
#include "client.h"
#include "paintredirector.h"
#include "shadow.h"
namespace KWin
@ -37,6 +38,7 @@ Deleted::Deleted(Workspace* ws)
, padding_bottom(0)
, m_layer(UnknownLayer)
, m_minimized(false)
, m_paintRedirector(NULL)
{
}
@ -88,10 +90,11 @@ void Deleted::copyToDeleted(Toplevel* c)
decoration_right,
decoration_bottom,
Client::WindowRelative);
decorationPixmapLeft = *client->leftDecoPixmap();
decorationPixmapRight = *client->rightDecoPixmap();
decorationPixmapTop = *client->topDecoPixmap();
decorationPixmapBottom = *client->bottomDecoPixmap();
if (PaintRedirector *redirector = client->decorationPaintRedirector()) {
redirector->ensurePixmapsPainted();
redirector->reparent(this);
m_paintRedirector = redirector;
}
}
m_minimized = client->isMinimized();
}

23
deleted.h
View file

@ -25,6 +25,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
namespace KWin
{
class PaintRedirector;
class Deleted
: public Toplevel
@ -43,18 +44,6 @@ public:
virtual QSize clientSize() const;
virtual QRect transparentRect() const;
virtual bool isDeleted() const;
const QPixmap *topDecoPixmap() const {
return &decorationPixmapTop;
}
const QPixmap *leftDecoPixmap() const {
return &decorationPixmapLeft;
}
const QPixmap *bottomDecoPixmap() const {
return &decorationPixmapBottom;
}
const QPixmap *rightDecoPixmap() const {
return &decorationPixmapRight;
}
bool noBorder() const {
return no_border;
}
@ -67,10 +56,9 @@ public:
return m_minimized;
}
NET::WindowType windowType(bool direct = false, int supported_types = 0) const;
bool decorationPixmapRequiresRepaint() const {
return false;
PaintRedirector *decorationPaintRedirector() {
return m_paintRedirector;
}
void ensureDecorationPixmapsPainted() {}
protected:
virtual void debug(QDebug& stream) const;
virtual bool shouldUnredirect() const;
@ -85,10 +73,6 @@ private:
QRect contentsRect; // for clientPos()/clientSize()
QRect transparent_rect;
QPixmap decorationPixmapLeft;
QPixmap decorationPixmapRight;
QPixmap decorationPixmapTop;
QPixmap decorationPixmapBottom;
bool no_border;
QRect decoration_left;
QRect decoration_right;
@ -97,6 +81,7 @@ private:
int padding_left, padding_top, padding_right, padding_bottom;
Layer m_layer;
bool m_minimized;
PaintRedirector *m_paintRedirector;
};
inline void Deleted::refWindow()

118
paintredirector.cpp
View file

@ -2,6 +2,7 @@
This file is part of the KDE project.
Copyright (C) 2009 Lubos Lunak <l.lunak@kde.org>
Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
@ -24,8 +25,11 @@ DEALINGS IN THE SOFTWARE.
#include "paintredirector.h"
#include "composite.h"
#include "client.h"
#include "deleted.h"
#include "effects.h"
#include <kdebug.h>
#include <QPaintEngine>
#include <qevent.h>
#include <qpainter.h>
#include <qmath.h>
@ -33,15 +37,39 @@ DEALINGS IN THE SOFTWARE.
namespace KWin
{
PaintRedirector::PaintRedirector(QWidget* w)
: widget(w)
PaintRedirector::PaintRedirector(Client *c, QWidget* w)
: QObject(w)
, widget(w)
, recursionCheck(false)
, m_client(c)
, m_responsibleForPixmap(!effects->isOpenGLCompositing())
, m_requiresRepaint(false)
{
added(w);
resizePixmaps();
}
PaintRedirector::~PaintRedirector()
{
if (m_responsibleForPixmap) {
for (int i=0; i<PixmapCount; ++i) {
XFreePixmap(display(), m_pixmaps[i].handle());
}
}
}
void PaintRedirector::reparent(Deleted *d)
{
setParent(d);
widget = NULL;
m_client = NULL;
}
QPixmap PaintRedirector::performPendingPaint()
{
if (!widget) {
return QPixmap();
}
//qDebug() << "### performing paint, pending:" << pending.boundingRect();
const QSize size = pending.boundingRect().size();
if (scratch.width() < size.width() || scratch.height() < size.height()) {
@ -54,8 +82,6 @@ QPixmap PaintRedirector::performPendingPaint()
// do not use DrawWindowBackground, it's ok to be transparent
widget->render(&scratch, QPoint(), pending.boundingRect(), QWidget::DrawChildren);
recursionCheck = false;
pending = QRegion();
scheduled = QRegion();
cleanupTimer.start(2000, this);
return scratch;
}
@ -68,6 +94,9 @@ bool PaintRedirector::isToolTip(QWidget *object) const
bool PaintRedirector::eventFilter(QObject* o, QEvent* e)
{
if (!widget || !m_client) {
return false;
}
switch(e->type()) {
case QEvent::ChildAdded: {
QChildEvent* c = static_cast< QChildEvent* >(e);
@ -82,15 +111,18 @@ bool PaintRedirector::eventFilter(QObject* o, QEvent* e)
break;
}
case QEvent::Paint: {
if (!Compositor::compositing()) {
return false;
}
if (!recursionCheck) {
QPaintEvent* pe = static_cast< QPaintEvent* >(e);
QWidget* w = static_cast< QWidget* >(o);
pending |= pe->region().translated(w->mapTo(widget, QPoint(0, 0)));
scheduled = pending;
emit paintPending();
// schedule repaint
const int paddingLeft = m_client->paddingLeft();
const int paddingTop = m_client->paddingTop();
const bool needsTranslate = (paddingLeft != 0 || paddingTop != 0);
m_client->addRepaint(needsTranslate ? pending.translated(-paddingLeft, -paddingTop) : pending);
m_requiresRepaint = true;
return true; // filter out
}
}
@ -138,6 +170,74 @@ void PaintRedirector::timerEvent(QTimerEvent* event)
}
}
void PaintRedirector::ensurePixmapsPainted()
{
if (pending.isEmpty() || !m_client)
return;
QPixmap p = performPendingPaint();
QRect rects[PixmapCount];
m_client->layoutDecorationRects(rects[LeftPixmap], rects[TopPixmap], rects[RightPixmap], rects[BottomPixmap], Client::DecorationRelative);
for (int i=0; i<PixmapCount; ++i) {
repaintPixmap(m_pixmaps[i], rects[i], p, pending);
}
pending = QRegion();
scheduled = QRegion();
XSync(display(), false);
}
void PaintRedirector::repaintPixmap(QPixmap &pix, const QRect &r, const QPixmap &src, QRegion reg)
{
if (!r.isValid())
return;
QRect b = reg.boundingRect();
reg &= r;
if (reg.isEmpty())
return;
QPainter pt(&pix);
pt.translate(-r.topLeft());
pt.setCompositionMode(QPainter::CompositionMode_Source);
pt.setClipRegion(reg);
pt.drawPixmap(b.topLeft(), src);
pt.end();
}
void PaintRedirector::resizePixmaps()
{
QRect rects[PixmapCount];
m_client->layoutDecorationRects(rects[LeftPixmap], rects[TopPixmap], rects[RightPixmap], rects[BottomPixmap], Client::DecorationRelative);
for (int i=0; i<PixmapCount; ++i) {
if (m_pixmaps[i].size() == rects[i].size()) {
// size unchanged, no need to recreate, but repaint
m_pixmaps[i].fill(Qt::transparent);
continue;
}
if (!m_responsibleForPixmap) {
m_pixmaps[i] = QPixmap(rects[i].size());
} else {
if (!m_pixmaps[i].isNull() && m_pixmaps[i].paintEngine()->type() == QPaintEngine::X11) {
XFreePixmap(display(), m_pixmaps[i].handle());
}
Pixmap xpix = XCreatePixmap(QX11Info::display(), rootWindow(),
rects[i].size().width(), rects[i].height(),
32);
m_pixmaps[i] = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
}
// Make sure the pixmaps are created with alpha channels
m_pixmaps[i].fill(Qt::transparent);
}
// repaint
if (widget) {
widget->update();
}
}
} // namespace
#include "paintredirector.moc"

55
paintredirector.h
View file

@ -2,6 +2,7 @@
This file is part of the KDE project.
Copyright (C) 2009 Lubos Lunak <l.lunak@kde.org>
Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
@ -32,6 +33,9 @@ DEALINGS IN THE SOFTWARE.
namespace KWin
{
// forward declarations
class Client;
class Deleted;
// This class redirects all painting of a given widget (including its children)
// into a paint device (QPixmap).
@ -40,24 +44,69 @@ class PaintRedirector
{
Q_OBJECT
public:
PaintRedirector(QWidget* widget);
enum DecorationPixmap {
TopPixmap,
RightPixmap,
BottomPixmap,
LeftPixmap,
PixmapCount
};
PaintRedirector(Client *c, QWidget* widget);
virtual ~PaintRedirector();
QPixmap performPendingPaint();
virtual bool eventFilter(QObject* o, QEvent* e);
QRegion pendingRegion() const;
QRegion scheduledRepaintRegion();
signals:
void paintPending();
void markAsRepainted() {
m_requiresRepaint = false;
}
bool requiresRepaint() const {
return m_requiresRepaint;
}
void resizePixmaps();
const QPixmap *topDecoPixmap() const {
return &m_pixmaps[TopPixmap];
}
const QPixmap *leftDecoPixmap() const {
return &m_pixmaps[LeftPixmap];
}
const QPixmap *bottomDecoPixmap() const {
return &m_pixmaps[BottomPixmap];
}
const QPixmap *rightDecoPixmap() const {
return &m_pixmaps[RightPixmap];
}
/**
* Used by Deleted::copyToDeleted() to move the PaintRedirector to the Deleted.
* The actual redirecting ends as the decoration gets destroyed after the Deleted
* is created.
**/
void reparent(Deleted *d);
public slots:
void ensurePixmapsPainted();
private:
void added(QWidget* widget);
void removed(QWidget* widget);
bool isToolTip(QWidget* widget) const;
void timerEvent(QTimerEvent* event);
void repaintPixmap(QPixmap& pix, const QRect& r, const QPixmap& src, QRegion reg);
QWidget* widget;
QRegion pending;
QRegion scheduled;
QPixmap scratch;
bool recursionCheck;
QBasicTimer cleanupTimer;
Client *m_client;
// we (instead of Qt) initialize the Pixmaps, and have to free them
bool m_responsibleForPixmap;
bool m_requiresRepaint;
QPixmap m_pixmaps[PixmapCount];
};
} // namespace

19
scene_opengl.cpp
View file

@ -83,6 +83,7 @@ Sources and other compositing managers:
#include "deleted.h"
#include "effects.h"
#include "overlaywindow.h"
#include "paintredirector.h"
#include <math.h>
@ -894,20 +895,21 @@ template<class T>
void SceneOpenGL::Window::paintDecorations(const WindowPaintData &data, const QRegion &region, bool hardwareClipping)
{
T* t = static_cast<T*>(toplevel);
if (t->noBorder()) {
PaintRedirector *redirector = t->decorationPaintRedirector();
if (t->noBorder() || !redirector) {
return;
}
WindowQuadList decoration = data.quads.select(WindowQuadDecoration);
QRect topRect, leftRect, rightRect, bottomRect;
const bool updateDeco = t->decorationPixmapRequiresRepaint();
t->ensureDecorationPixmapsPainted();
const bool updateDeco = redirector->requiresRepaint();
t->layoutDecorationRects(leftRect, topRect, rightRect, bottomRect, Client::WindowRelative);
const QPixmap *left = t->leftDecoPixmap();
const QPixmap *top = t->topDecoPixmap();
const QPixmap *right = t->rightDecoPixmap();
const QPixmap *bottom = t->bottomDecoPixmap();
const QPixmap *left = redirector->leftDecoPixmap();
const QPixmap *top = redirector->topDecoPixmap();
const QPixmap *right = redirector->rightDecoPixmap();
const QPixmap *bottom = redirector->bottomDecoPixmap();
WindowQuadList topList, leftList, rightList, bottomList;
foreach (const WindowQuad & quad, decoration) {
@ -929,10 +931,13 @@ void SceneOpenGL::Window::paintDecorations(const WindowPaintData &data, const QR
}
}
redirector->ensurePixmapsPainted();
paintDecoration(top, DecorationTop, region, topRect, data, topList, updateDeco, hardwareClipping);
paintDecoration(left, DecorationLeft, region, leftRect, data, leftList, updateDeco, hardwareClipping);
paintDecoration(right, DecorationRight, region, rightRect, data, rightList, updateDeco, hardwareClipping);
paintDecoration(bottom, DecorationBottom, region, bottomRect, data, bottomList, updateDeco, hardwareClipping);
redirector->markAsRepainted();
}

23
scene_xrender.cpp
View file

@ -47,6 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "deleted.h"
#include "effects.h"
#include "overlaywindow.h"
#include "paintredirector.h"
#include "kwinxrenderutils.h"
#include <X11/extensions/Xcomposite.h>
@ -584,25 +585,26 @@ void SceneXrender::Window::performPaint(int mask, QRegion region, WindowPaintDat
const QPixmap *top = NULL;
const QPixmap *right = NULL;
const QPixmap *bottom = NULL;
PaintRedirector *redirector = NULL;
QRect dtr, dlr, drr, dbr;
if (client || deleted) {
if (client && !client->noBorder()) {
client->ensureDecorationPixmapsPainted();
redirector = client->decorationPaintRedirector();
noBorder = client->noBorder();
left = client->leftDecoPixmap();
top = client->topDecoPixmap();
right = client->rightDecoPixmap();
bottom = client->bottomDecoPixmap();
client->layoutDecorationRects(dlr, dtr, drr, dbr, Client::WindowRelative);
}
if (deleted && !deleted->noBorder()) {
noBorder = deleted->noBorder();
left = deleted->leftDecoPixmap();
top = deleted->topDecoPixmap();
right = deleted->rightDecoPixmap();
bottom = deleted->bottomDecoPixmap();
redirector = deleted->decorationPaintRedirector();
deleted->layoutDecorationRects(dlr, dtr, drr, dbr);
}
if (redirector) {
redirector->ensurePixmapsPainted();
left = redirector->leftDecoPixmap();
top = redirector->topDecoPixmap();
right = redirector->rightDecoPixmap();
bottom = redirector->bottomDecoPixmap();
}
if (!noBorder) {
MAP_RECT_TO_TARGET(dtr);
MAP_RECT_TO_TARGET(dlr);
@ -686,6 +688,9 @@ XRenderComposite(display(), PictOpOver, _PART_->x11PictureHandle(), decorationAl
RENDER_DECO_PART(right, drr);
RENDER_DECO_PART(bottom, dbr);
}
if (redirector) {
redirector->markAsRepainted();
}
}
#undef RENDER_DECO_PART