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

259 lines
7.2 KiB
C
Raw Normal View History

Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
/*****************************************************************
This file is part of the KDE project.
Copyright (C) 2009 Lubos Lunak <l.lunak@kde.org>
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
******************************************************************/
#ifndef PAINTREDIRECTOR_H
#define PAINTREDIRECTOR_H
#include <qregion.h>
#include <qtimer.h>
#include <qwidget.h>
Wait two seconds before deleting the scratch pixmap in the paint redirector in case we need it again. This should improve performance with drivers where creating pixmaps is expensive. svn path=/trunk/KDE/kdebase/workspace/; revision=1104069
2010-03-16 16:34:39 +00:00
#include <qbasictimer.h>
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
// xcb
#include <xcb/render.h>
Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
namespace KWin
{
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
// forward declarations
class Client;
class Deleted;
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
class XRenderPicture;
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
class GLTexture;
Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
// This class redirects all painting of a given widget (including its children)
// into a paint device (QPixmap).
class PaintRedirector
: public QObject
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
Q_OBJECT
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
public:
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
enum DecorationPixmap {
TopPixmap,
RightPixmap,
BottomPixmap,
LeftPixmap,
PixmapCount
};
virtual ~PaintRedirector();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
virtual bool eventFilter(QObject* o, QEvent* e);
QRegion pendingRegion() const;
QRegion scheduledRepaintRegion();
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
void markAsRepainted() {
m_requiresRepaint = false;
}
bool requiresRepaint() const {
return m_requiresRepaint;
}
void resizePixmaps();
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
template <typename T>
T topDecoPixmap() const;
template <typename T>
T leftDecoPixmap() const;
template <typename T>
T bottomDecoPixmap() const;
template <typename T>
T rightDecoPixmap() const;
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
/**
* 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);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
static PaintRedirector *create(Client *c, QWidget* widget);
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
public slots:
void ensurePixmapsPainted();
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
protected:
PaintRedirector(Client *c, QWidget* widget);
virtual xcb_render_picture_t picture(DecorationPixmap border) const;
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
virtual GLTexture *texture(DecorationPixmap border) const;
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
virtual void resize(DecorationPixmap border, const QSize &size) = 0;
virtual void preparePaint(const QPixmap &pending);
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
virtual void paint(DecorationPixmap border, const QRect& r, const QRect &b, const QRegion &reg) = 0;
virtual QPaintDevice *scratch() = 0;
virtual QPaintDevice *recreateScratch(const QSize &size) = 0;
virtual void fillScratch(Qt::GlobalColor color) = 0;
virtual void discardScratch() = 0;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
private:
void added(QWidget* widget);
void removed(QWidget* widget);
bool isToolTip(QWidget* widget) const;
void timerEvent(QTimerEvent* event);
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
void performPendingPaint();
void repaintPixmap(DecorationPixmap border, const QRect& r, QRegion reg);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QWidget* widget;
QRegion pending;
QRegion scheduled;
bool recursionCheck;
QBasicTimer cleanupTimer;
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
Client *m_client;
bool m_requiresRepaint;
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
};
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
class ImageBasedPaintRedirector : public PaintRedirector
{
Q_OBJECT
public:
virtual ~ImageBasedPaintRedirector();
protected:
ImageBasedPaintRedirector(Client *c, QWidget *widget);
virtual QPaintDevice *recreateScratch(const QSize &size);
virtual QPaintDevice *scratch();
virtual void fillScratch(Qt::GlobalColor color);
virtual void discardScratch();
const QImage &scratchImage() const;
private:
QImage m_scratchImage;
};
class OpenGLPaintRedirector : public ImageBasedPaintRedirector
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
{
Q_OBJECT
public:
OpenGLPaintRedirector(Client *c, QWidget *widget);
virtual ~OpenGLPaintRedirector();
protected:
virtual void resize(DecorationPixmap border, const QSize &size);
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
virtual void paint(DecorationPixmap border, const QRect &r, const QRect &b, const QRegion &reg);
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
virtual GLTexture *texture(DecorationPixmap border) const;
virtual void preparePaint(const QPixmap &pending);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
private:
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
QImage m_tempImage;
GLTexture* m_textures[PixmapCount];
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
};
class NativeXRenderPaintRedirector : public PaintRedirector
{
Q_OBJECT
public:
NativeXRenderPaintRedirector(Client *c, QWidget *widget);
virtual ~NativeXRenderPaintRedirector();
protected:
virtual xcb_render_picture_t picture(DecorationPixmap border) const;
virtual void resize(DecorationPixmap border, const QSize &size);
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
virtual void paint(DecorationPixmap border, const QRect &r, const QRect &b, const QRegion &reg);
virtual void fillScratch(Qt::GlobalColor color);
virtual QPaintDevice *recreateScratch(const QSize &size);
virtual QPaintDevice *scratch();
virtual void discardScratch();
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
private:
Move decoration pixmap handling from Client to PaintRedirector 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
2012-09-28 09:59:42 +00:00
QPixmap m_pixmaps[PixmapCount];
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
QPixmap m_scratch;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
};
Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
class RasterXRenderPaintRedirector : public ImageBasedPaintRedirector
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
{
Q_OBJECT
public:
RasterXRenderPaintRedirector(Client *c, QWidget *widget);
virtual ~RasterXRenderPaintRedirector();
protected:
virtual xcb_render_picture_t picture(DecorationPixmap border) const;
virtual void resize(DecorationPixmap border, const QSize &size);
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
virtual void paint(DecorationPixmap border, const QRect &r, const QRect &b, const QRegion &reg);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
virtual void preparePaint(const QPixmap &pending);
private:
QSize m_sizes[PixmapCount];
xcb_pixmap_t m_pixmaps[PixmapCount];
xcb_gcontext_t m_gc;
XRenderPicture* m_pictures[PixmapCount];
QImage m_tempImage;
};
template <>
inline
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
GLTexture *PaintRedirector::bottomDecoPixmap() const
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
{
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
return texture(BottomPixmap);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
}
template <>
inline
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
GLTexture *PaintRedirector::leftDecoPixmap() const
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
{
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
return texture(LeftPixmap);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
}
template <>
inline
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
GLTexture *PaintRedirector::rightDecoPixmap() const
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
{
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
return texture(RightPixmap);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
}
template <>
inline
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
GLTexture *PaintRedirector::topDecoPixmap() const
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
{
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
return texture(TopPixmap);
Introduce dedicated PaintRedirector subclasses for OpenGL/XRender PaintRedirector is turned into an abstract class providing a factory method which returns either an instance of * OpenGLPaintRedirector * NativeXRenderPaintRedirector * RasterXRenderPaintRedirector OpenGLPaintRedirector is basically doing exactly the same as the parent class used to do before. Though the idea is to extend the functionality to have the PaintRedirector write directly into OpenGL textures to limit copying the complete decorations. NativeXRenderPaintRedirector is similar to OpenGLPaintRedirector by rendering into a QPixmap and providing the pictureHandle for the QPixmap to SceneXRender. RasterXRenderPaintRedirector is providing the functionality for the case that the QPixmap/XPixmap relationship is not present. From the QPixmap containing the pending decoration paint a QImage is created and then the relevent parts are copied directly into the decoration pixmap. REVIEW: 109074
2013-02-18 08:07:42 +00:00
}
template <>
inline
xcb_render_picture_t PaintRedirector::bottomDecoPixmap() const
{
return picture(BottomPixmap);
}
template <>
inline
xcb_render_picture_t PaintRedirector::leftDecoPixmap() const
{
return picture(LeftPixmap);
}
template <>
inline
xcb_render_picture_t PaintRedirector::rightDecoPixmap() const
{
return picture(RightPixmap);
}
template <>
inline
xcb_render_picture_t PaintRedirector::topDecoPixmap() const
{
return picture(TopPixmap);
}
Do not needlessly copy from QPixmap to QImage in PaintRedirector The scratch PaintDevice is provided by the PaintRedirector's subclasses allowing the ones wanting a QImage to provide the QImage directly and the ones needing a QPixmap to provide a pixmap. This means the copy from QPixmap to QImage is no longer needed in the OpenGL and XRender/raster paint redirector. REVIEW: 109138
2013-02-25 09:18:02 +00:00
inline
const QImage &ImageBasedPaintRedirector::scratchImage() const
{
return m_scratchImage;
}
Implement initial support for ARGB window decorations. Based on earlier work done by Lubos Lunak and ideas by Lucas Murray. svn path=/trunk/KDE/kdebase/workspace/; revision=957680
2009-04-22 17:29:56 +00:00
} // namespace
#endif
Reference in a new issue Copy permalink