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

223 lines
11 KiB
C++
Raw Normal View History

Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2011 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "shadow.h"
// kwin
#include "atoms.h"
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
#include "effects.h"
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
#include "toplevel.h"
#include "scene_opengl.h"
kwin: Implement shadows in XRender compositor There are still some glitches to be fixed, but it works well for most use-cases.
2011-04-28 15:22:17 +00:00
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
#include "scene_xrender.h"
#endif
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
namespace KWin
{
Shadow::Shadow(Toplevel *toplevel)
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
: m_topLevel(toplevel)
Update cached Shadow information on size changes In order to notice when the geometry changes a new signal is added to toplevel and both Unmanaged and Client connect all their signals which are emitted whenever the geometry changes in some way to this new signal. Shadow connects to the signal and updates the quads and region whenever the size changes.
2011-04-03 10:43:57 +00:00
, m_cachedSize(toplevel->geometry().size())
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
{
Update cached Shadow information on size changes In order to notice when the geometry changes a new signal is added to toplevel and both Unmanaged and Client connect all their signals which are emitted whenever the geometry changes in some way to this new signal. Shadow connects to the signal and updates the quads and region whenever the size changes.
2011-04-03 10:43:57 +00:00
connect(m_topLevel, SIGNAL(geometryChanged()), SLOT(geometryChanged()));
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
Shadow::~Shadow()
{
}
Shadow *Shadow::createShadow(Toplevel *toplevel)
{
if (!effects) {
return NULL;
}
QVector<long> data = Shadow::readX11ShadowProperty(toplevel->window());
if (!data.isEmpty()) {
Shadow *shadow = NULL;
if (effects->compositingType() == OpenGLCompositing) {
shadow = new SceneOpenGLShadow(toplevel);
kwin: Implement shadows in XRender compositor There are still some glitches to be fixed, but it works well for most use-cases.
2011-04-28 15:22:17 +00:00
} else if (effects->compositingType() == XRenderCompositing) {
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
shadow = new SceneXRenderShadow(toplevel);
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
#endif
}
kwin: Implement shadows in XRender compositor There are still some glitches to be fixed, but it works well for most use-cases.
2011-04-28 15:22:17 +00:00
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
if (shadow) {
Verify that Shadow pixmaps are valid At least in rekonq the shadow pixmaps are not valid causing an exception to be thrown and crashing kwin.
2011-04-02 17:01:16 +00:00
if (!shadow->init(data)) {
delete shadow;
return NULL;
}
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
if (toplevel->effectWindow() && toplevel->effectWindow()->sceneWindow()) {
toplevel->effectWindow()->sceneWindow()->updateShadow(shadow);
}
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
return shadow;
} else {
return NULL;
}
}
QVector< long > Shadow::readX11ShadowProperty(WId id)
{
QVector<long> ret;
Atom type;
int format, status;
unsigned long nitems = 0;
unsigned long extra = 0;
unsigned char *data = 0;
status = XGetWindowProperty(display(), id, atoms->kde_net_wm_shadow, 0, 12, false, XA_CARDINAL, &type, &format, &nitems, &extra, &data);
if (status == Success && type == XA_CARDINAL && format == 32 && nitems == 12) {
long* shadow = reinterpret_cast< long* >(data);
ret.reserve(12);
for (int i=0; i<12; ++i) {
ret << shadow[i];
}
XFree(data);
}
return ret;
}
Verify that Shadow pixmaps are valid At least in rekonq the shadow pixmaps are not valid causing an exception to be thrown and crashing kwin.
2011-04-02 17:01:16 +00:00
bool Shadow::init(const QVector< long > &data)
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
{
for (int i=0; i<ShadowElementsCount; ++i) {
Deep copy of Shadow pixmap again Basically revert of fb9afb61f8c1e7db4ae034435a9d54b5e87977d5. Fixes an issue of black shadows which could sometimes happen in OpenGL backend.
2011-06-17 17:48:14 +00:00
QPixmap pix = QPixmap::fromX11Pixmap(data[i], QPixmap::ExplicitlyShared);
Add another pixmap safety check in Shadow creation Do not only check for null pixmaps but also that the pixmap contains a 32 bit depth as we don't want shadows without alpha.
2011-05-14 19:02:11 +00:00
if (pix.isNull() || pix.depth() != 32) {
Verify that Shadow pixmaps are valid At least in rekonq the shadow pixmaps are not valid causing an exception to be thrown and crashing kwin.
2011-04-02 17:01:16 +00:00
return false;
}
Deep copy of Shadow pixmap again Basically revert of fb9afb61f8c1e7db4ae034435a9d54b5e87977d5. Fixes an issue of black shadows which could sometimes happen in OpenGL backend.
2011-06-17 17:48:14 +00:00
m_shadowElements[i] = pix.copy(0, 0, pix.width(), pix.height());
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
m_topOffset = data[ShadowElementsCount];
m_rightOffset = data[ShadowElementsCount+1];
m_bottomOffset = data[ShadowElementsCount+2];
m_leftOffset = data[ShadowElementsCount+3];
Update cached Shadow information on size changes In order to notice when the geometry changes a new signal is added to toplevel and both Unmanaged and Client connect all their signals which are emitted whenever the geometry changes in some way to this new signal. Shadow connects to the signal and updates the quads and region whenever the size changes.
2011-04-03 10:43:57 +00:00
updateShadowRegion();
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
if (!prepareBackend()) {
return false;
}
Update cached Shadow information on size changes In order to notice when the geometry changes a new signal is added to toplevel and both Unmanaged and Client connect all their signals which are emitted whenever the geometry changes in some way to this new signal. Shadow connects to the signal and updates the quads and region whenever the size changes.
2011-04-03 10:43:57 +00:00
buildQuads();
return true;
}
void Shadow::updateShadowRegion()
{
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
const QRect topRect(0, - m_topOffset, m_topLevel->width(), m_topOffset);
const QRect rightRect(m_topLevel->width(), - m_topOffset, m_rightOffset, m_topLevel->height() + m_topOffset + m_bottomOffset);
const QRect bottomRect(0, m_topLevel->height(), m_topLevel->width(), m_bottomOffset);
const QRect leftRect(- m_leftOffset, - m_topOffset, m_leftOffset, m_topLevel->height() + m_topOffset + m_bottomOffset);
m_shadowRegion = QRegion(topRect).united(rightRect).united(bottomRect).united(leftRect);
}
void Shadow::buildQuads()
{
// prepare window quads
m_shadowQuads.clear();
const QRect topRect(QPoint(0, 0), m_shadowElements[ShadowElementTop].size());
const QRect topRightRect(QPoint(0, 0), m_shadowElements[ShadowElementTopRight].size());
const QRect rightRect(QPoint(0, 0), m_shadowElements[ShadowElementRight].size());
const QRect bottomRightRect(QPoint(0, 0), m_shadowElements[ShadowElementBottomRight].size());
const QRect bottomRect(QPoint(0, 0), m_shadowElements[ShadowElementBottom].size());
const QRect bottomLeftRect(QPoint(0, 0), m_shadowElements[ShadowElementBottomLeft].size());
const QRect leftRect(QPoint(0, 0), m_shadowElements[ShadowElementLeft].size());
const QRect topLeftRect(QPoint(0, 0), m_shadowElements[ShadowElementTopLeft].size());
Don't render a Shadow if the Shadow overlaps the window
2011-04-03 11:05:35 +00:00
if ((leftRect.width() - m_leftOffset > m_topLevel->width()) ||
(rightRect.width() - m_rightOffset > m_topLevel->width()) ||
(topRect.height() - m_topOffset > m_topLevel->height()) ||
(bottomRect.height() - m_bottomOffset > m_topLevel->height())) {
// if our shadow is bigger than the window, we don't render the shadow
m_shadowRegion = QRegion();
return;
}
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
WindowQuad topLeftQuad(WindowQuadShadowTopLeft);
topLeftQuad[ 0 ] = WindowVertex(-m_leftOffset, -m_topOffset, 0.0, 0.0);
topLeftQuad[ 1 ] = WindowVertex(-m_leftOffset + topLeftRect.width(), -m_topOffset, 1.0, 0.0);
topLeftQuad[ 2 ] = WindowVertex(-m_leftOffset + topLeftRect.width(), -m_topOffset + topLeftRect.height(), 1.0, 1.0);
topLeftQuad[ 3 ] = WindowVertex(-m_leftOffset, -m_topOffset + topLeftRect.height(), 0.0, 1.0);
m_shadowQuads.append(topLeftQuad);
WindowQuad topQuad(WindowQuadShadowTop);
topQuad[ 0 ] = WindowVertex(-m_leftOffset + topLeftRect.width(), -m_topOffset, 0.0, 0.0);
topQuad[ 1 ] = WindowVertex(m_topLevel->width() + m_rightOffset - topRightRect.width(), -m_topOffset, 1.0, 0.0);
topQuad[ 2 ] = WindowVertex(m_topLevel->width() + m_rightOffset - topRightRect.width(), -m_topOffset + topRect.height(), 1.0, 1.0);
topQuad[ 3 ] = WindowVertex(-m_leftOffset + topLeftRect.width(), -m_topOffset + topRect.height(), 0.0, 1.0);
m_shadowQuads.append(topQuad);
WindowQuad topRightQuad(WindowQuadShadowTopRight);
topRightQuad[ 0 ] = WindowVertex(m_topLevel->width() + m_rightOffset - topRightRect.width(), -m_topOffset, 0.0, 0.0);
topRightQuad[ 1 ] = WindowVertex(m_topLevel->width() + m_rightOffset, -m_topOffset, 1.0, 0.0);
topRightQuad[ 2 ] = WindowVertex(m_topLevel->width() + m_rightOffset, -m_topOffset + topRightRect.height(), 1.0, 1.0);
topRightQuad[ 3 ] = WindowVertex(m_topLevel->width() + m_rightOffset - topRightRect.width(), -m_topOffset + topRightRect.height(), 0.0, 1.0);
m_shadowQuads.append(topRightQuad);
WindowQuad rightQuad(WindowQuadShadowRight);
rightQuad[ 0 ] = WindowVertex(m_topLevel->width() + m_rightOffset - rightRect.width(), -m_topOffset + topRightRect.height(), 0.0, 0.0);
rightQuad[ 1 ] = WindowVertex(m_topLevel->width() + m_rightOffset, -m_topOffset + topRightRect.height(), 1.0, 0.0);
rightQuad[ 2 ] = WindowVertex(m_topLevel->width() + m_rightOffset, m_topLevel->height() + m_bottomOffset - bottomRightRect.height(), 1.0, 1.0);
rightQuad[ 3 ] = WindowVertex(m_topLevel->width() + m_rightOffset - rightRect.width(), m_topLevel->height() + m_bottomOffset - bottomRightRect.height(), 0.0, 1.0);
m_shadowQuads.append(rightQuad);
WindowQuad bottomRightQuad(WindowQuadShadowBottomRight);
bottomRightQuad[ 0 ] = WindowVertex(m_topLevel->width() + m_rightOffset - bottomRightRect.width(), m_topLevel->height() + m_bottomOffset - bottomRightRect.height(), 0.0, 0.0);
bottomRightQuad[ 1 ] = WindowVertex(m_topLevel->width() + m_rightOffset, m_topLevel->height() + m_bottomOffset - bottomRightRect.height(), 1.0, 0.0);
bottomRightQuad[ 2 ] = WindowVertex(m_topLevel->width() + m_rightOffset, m_topLevel->height() + m_bottomOffset, 1.0, 1.0);
bottomRightQuad[ 3 ] = WindowVertex(m_topLevel->width() + m_rightOffset - bottomRightRect.width(), m_topLevel->height() + m_bottomOffset, 0.0, 1.0);
m_shadowQuads.append(bottomRightQuad);
WindowQuad bottomQuad(WindowQuadShadowBottom);
bottomQuad[ 0 ] = WindowVertex(-m_leftOffset + bottomLeftRect.width(), m_topLevel->height() + m_bottomOffset - bottomRect.height(), 0.0, 0.0);
bottomQuad[ 1 ] = WindowVertex(m_topLevel->width() + m_rightOffset - bottomRightRect.width(), m_topLevel->height() + m_bottomOffset - bottomRect.height(), 1.0, 0.0);
bottomQuad[ 2 ] = WindowVertex(m_topLevel->width() + m_rightOffset - bottomRightRect.width(), m_topLevel->height() + m_bottomOffset, 1.0, 1.0);
bottomQuad[ 3 ] = WindowVertex(-m_leftOffset + bottomLeftRect.width(), m_topLevel->height() + m_bottomOffset, 0.0, 1.0);
m_shadowQuads.append(bottomQuad);
WindowQuad bottomLeftQuad(WindowQuadShadowBottomLeft);
bottomLeftQuad[ 0 ] = WindowVertex(-m_leftOffset, m_topLevel->height() + m_bottomOffset - bottomLeftRect.height(), 0.0, 0.0);
bottomLeftQuad[ 1 ] = WindowVertex(-m_leftOffset + bottomLeftRect.width(), m_topLevel->height() + m_bottomOffset - bottomLeftRect.height(), 1.0, 0.0);
bottomLeftQuad[ 2 ] = WindowVertex(-m_leftOffset + bottomLeftRect.width(), m_topLevel->height() + m_bottomOffset, 1.0, 1.0);
bottomLeftQuad[ 3 ] = WindowVertex(-m_leftOffset, m_topLevel->height() + m_bottomOffset, 0.0, 1.0);
m_shadowQuads.append(bottomLeftQuad);
WindowQuad leftQuad(WindowQuadShadowLeft);
leftQuad[ 0 ] = WindowVertex(-m_leftOffset, -m_topOffset + topLeftRect.height(), 0.0, 0.0);
leftQuad[ 1 ] = WindowVertex(-m_leftOffset + leftRect.width(), -m_topOffset + topLeftRect.height(), 1.0, 0.0);
leftQuad[ 2 ] = WindowVertex(-m_leftOffset + leftRect.width(), m_topLevel->height() + m_bottomOffset - bottomLeftRect.height(), 1.0, 1.0);
leftQuad[ 3 ] = WindowVertex(-m_leftOffset, m_topLevel->height() + m_bottomOffset - bottomLeftRect.height(), 0.0, 1.0);
m_shadowQuads.append(leftQuad);
}
bool Shadow::updateShadow()
{
QVector<long> data = Shadow::readX11ShadowProperty(m_topLevel->window());
if (data.isEmpty()) {
return false;
}
init(data);
fix shadow quad update, allows to change shadow size with property update (been OpenGL issue only) fix TopLevel::visibleRect, broke shaded windows with empty (too big) shadows REVIEW: 103231 (cherry picked from commit 535d40e7b4ca5a4431446c3d5c70e6d52f541fae)
2011-11-25 00:00:54 +00:00
if (m_topLevel && m_topLevel->effectWindow())
m_topLevel->effectWindow()->buildQuads(true);
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
return true;
}
Fix repainting of shadow after window closes Unmanaged needs to repaint the complete geometry including shadow when it ends compositing. Therefore we need to track the shadow passing to deleted correctly. Disadvantage: when turning off compositing the shadow is kept. Need to solve in a better way!
2011-04-01 19:49:44 +00:00
void Shadow::setToplevel(Toplevel *topLevel)
{
m_topLevel = topLevel;
Update cached Shadow information on size changes In order to notice when the geometry changes a new signal is added to toplevel and both Unmanaged and Client connect all their signals which are emitted whenever the geometry changes in some way to this new signal. Shadow connects to the signal and updates the quads and region whenever the size changes.
2011-04-03 10:43:57 +00:00
connect(m_topLevel, SIGNAL(geometryChanged()), SLOT(geometryChanged()));
}
void Shadow::geometryChanged()
{
if (m_cachedSize == m_topLevel->geometry().size()) {
return;
}
m_cachedSize = m_topLevel->geometry().size();
updateShadowRegion();
buildQuads();
Fix repainting of shadow after window closes Unmanaged needs to repaint the complete geometry including shadow when it ends compositing. Therefore we need to track the shadow passing to deleted correctly. Disadvantage: when turning off compositing the shadow is kept. Need to solve in a better way!
2011-04-01 19:49:44 +00:00
}
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
} // namespace
Reference in a new issue Copy permalink