448 lines
15 KiB
C++
448 lines
15 KiB
C++
/*****************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
You can Freely distribute this program under the GNU General Public
|
|
License. See the file "COPYING" for the exact licensing terms.
|
|
******************************************************************/
|
|
|
|
#include "scene_xrender.h"
|
|
|
|
#ifdef HAVE_XRENDER
|
|
|
|
#include "toplevel.h"
|
|
#include "client.h"
|
|
#include "effects.h"
|
|
|
|
namespace KWinInternal
|
|
{
|
|
|
|
//****************************************
|
|
// SceneXrender
|
|
//****************************************
|
|
|
|
struct RegionDebug
|
|
{
|
|
RegionDebug( XserverRegion r ) : rr( r ) {}
|
|
XserverRegion rr;
|
|
};
|
|
|
|
#ifdef NDEBUG
|
|
inline
|
|
kndbgstream& operator<<( kndbgstream& stream, RegionDebug ) { return stream; }
|
|
#else
|
|
kdbgstream& operator<<( kdbgstream& stream, RegionDebug r )
|
|
{
|
|
if( r.rr == None )
|
|
return stream << "EMPTY";
|
|
int num;
|
|
XRectangle* rects = XFixesFetchRegion( display(), r.rr, &num );
|
|
if( rects == NULL || num == 0 )
|
|
return stream << "EMPTY";
|
|
for( int i = 0;
|
|
i < num;
|
|
++i )
|
|
stream << "[" << rects[ i ].x << "+" << rects[ i ].y << " " << rects[ i ].width << "x" << rects[ i ].height << "]";
|
|
return stream;
|
|
}
|
|
#endif
|
|
|
|
SceneXrender::SceneXrender( Workspace* ws )
|
|
: Scene( ws )
|
|
{
|
|
format = XRenderFindVisualFormat( display(), DefaultVisual( display(), DefaultScreen( display())));
|
|
XRenderPictureAttributes pa;
|
|
pa.subwindow_mode = IncludeInferiors;
|
|
front = XRenderCreatePicture( display(), rootWindow(), format, CPSubwindowMode, &pa );
|
|
createBuffer();
|
|
}
|
|
|
|
SceneXrender::~SceneXrender()
|
|
{
|
|
XRenderFreePicture( display(), front );
|
|
XRenderFreePicture( display(), buffer );
|
|
for( QMap< Toplevel*, WindowData >::Iterator it = window_data.begin();
|
|
it != window_data.end();
|
|
++it )
|
|
(*it).free();
|
|
}
|
|
|
|
void SceneXrender::paint( QRegion dam, ToplevelList windows )
|
|
{
|
|
#if 1
|
|
dam = QRegion( 0, 0, displayWidth(), displayHeight());
|
|
#endif
|
|
QVector< QRect > rects = dam.rects();
|
|
XRectangle* xr = new XRectangle[ rects.count() ];
|
|
for( int i = 0;
|
|
i < rects.count();
|
|
++i )
|
|
{
|
|
xr[ i ].x = rects[ i ].x();
|
|
xr[ i ].y = rects[ i ].y();
|
|
xr[ i ].width = rects[ i ].width();
|
|
xr[ i ].height = rects[ i ].height();
|
|
}
|
|
XserverRegion damage = XFixesCreateRegion( display(), xr, rects.count());
|
|
delete[] xr;
|
|
// Use the damage region as the clip region for the root window
|
|
XFixesSetPictureClipRegion( display(), front, 0, 0, damage );
|
|
// Prepare pass for windows
|
|
// Go top to bottom so that clipping is computed properly for phase1
|
|
for( int i = windows.count() - 1;
|
|
i >= 0;
|
|
--i )
|
|
{
|
|
Toplevel* c = windows[ i ];
|
|
resetWindowData( c );
|
|
WindowData& data = window_data[ c ];
|
|
Picture picture = data.picture();
|
|
if( picture == None ) // The render format can be null for GL and/or Xv visuals
|
|
{
|
|
windows.removeAt( i );
|
|
continue;
|
|
}
|
|
effects->transformWindow( c, data.matrix, data.effect ); // TODO remove, instead add initWindow() to effects
|
|
effects->transformWorkspace( data.matrix, data.effect );
|
|
data.saveClipRegion( damage );
|
|
if( data.simpleTransformation() && data.isOpaque())
|
|
{ // is opaque, has simple shape, can be clipped, will be painted using simpler faster method
|
|
// Subtract the clients shape from the damage region
|
|
XserverRegion shape = data.shape();
|
|
assert( shape != None );
|
|
XFixesSubtractRegion( display(), damage, damage, shape );
|
|
data.phase = 1;
|
|
}
|
|
else
|
|
data.phase = 2; // will be painted later bottom to top
|
|
}
|
|
// Fill any areas of the root window not covered by windows
|
|
XFixesSetPictureClipRegion( display(), buffer, 0, 0, damage );
|
|
XRenderColor col = { 0xffff, 0xffff, 0xffff, 0xffff };
|
|
XRenderFillRectangle( display(), PictOpSrc, buffer, &col, 0, 0, displayWidth(), displayHeight());
|
|
// Draw each opaque window top to bottom, subtracting the bounding rect of
|
|
// each window from the clip region after it's been drawn.
|
|
for( int i = windows.count() - 1;
|
|
i >= 0;
|
|
--i )
|
|
{
|
|
Toplevel* c = windows[ i ];
|
|
WindowData& data = window_data[ c ];
|
|
if( data.phase != 1 )
|
|
continue;
|
|
XFixesSetPictureClipRegion( display(), buffer, 0, 0, data.savedClipRegion());
|
|
Picture picture = data.picture();
|
|
XRenderComposite( display(), PictOpSrc, picture, None, buffer, 0, 0, 0, 0,
|
|
c->x() + int( data.matrix.xTranslate()), c->y() + int( data.matrix.yTranslate()), c->width(), c->height());
|
|
}
|
|
// Now walk the list bottom to top, drawing translucent and complicated windows.
|
|
// That we draw bottom to top is important now since we're drawing translucent objects
|
|
// and also are clipping only by opaque windows.
|
|
for( int i = 0;
|
|
i < windows.count();
|
|
++i )
|
|
{
|
|
Toplevel* c = windows[ i ];
|
|
WindowData& data = window_data[ c ];
|
|
if( data.phase != 2 )
|
|
continue;
|
|
XFixesSetPictureClipRegion( display(), buffer, 0, 0, data.savedClipRegion());
|
|
Picture picture = data.picture();
|
|
Picture alpha = data.alphaMask();
|
|
if( data.simpleTransformation())
|
|
{
|
|
XRenderComposite( display(), PictOpOver, picture, alpha, buffer, 0, 0, 0, 0,
|
|
c->x() + int( data.matrix.xTranslate()), c->y() + int( data.matrix.yTranslate()), c->width(), c->height());
|
|
}
|
|
else
|
|
{
|
|
// TODO Okay, I'm at loss here. Whoever wants advanced transformations can implement
|
|
// it themselves. If not, they actually don't want it that badly *shrug*.
|
|
// setPictureMatrix( picture, data.matrix );
|
|
XRenderComposite( display(), PictOpSrc, picture, alpha, buffer, 0, 0, 0, 0,
|
|
c->x(), c->y(), c->width(), c->height());
|
|
// setPictureMatrix( picture, Matrix());
|
|
}
|
|
}
|
|
// cleanup
|
|
for( int i = 0;
|
|
i < windows.count();
|
|
++i )
|
|
{
|
|
Toplevel* c = windows[ i ];
|
|
WindowData& data = window_data[ c ];
|
|
data.cleanup();
|
|
}
|
|
// copy composed buffer to the root window
|
|
XFixesSetPictureClipRegion( display(), buffer, 0, 0, None );
|
|
XRenderComposite( display(), PictOpSrc, buffer, None, front, 0, 0, 0, 0, 0, 0, displayWidth(), displayHeight());
|
|
XFlush( display());
|
|
XFixesDestroyRegion( display(), damage );
|
|
}
|
|
|
|
void SceneXrender::resetWindowData( Toplevel* c )
|
|
{
|
|
if( !window_data.contains( c ))
|
|
window_data[ c ] = WindowData( c, XRenderFindVisualFormat( display(), c->visual()));
|
|
WindowData& data = window_data[ c ];
|
|
data.matrix = Matrix();
|
|
data.effect.opacity = c->opacity();
|
|
}
|
|
|
|
void SceneXrender::windowGeometryShapeChanged( Toplevel* c )
|
|
{
|
|
if( !window_data.contains( c ))
|
|
return;
|
|
window_data[ c ].geometryShapeChanged();
|
|
}
|
|
|
|
void SceneXrender::windowOpacityChanged( Toplevel* c )
|
|
{
|
|
if( !window_data.contains( c ))
|
|
return;
|
|
window_data[ c ].opacityChanged();
|
|
}
|
|
|
|
void SceneXrender::windowDeleted( Toplevel* c )
|
|
{
|
|
assert( window_data.contains( c ));
|
|
window_data[ c ].free();
|
|
window_data.remove( c );
|
|
}
|
|
|
|
void SceneXrender::windowAdded( Toplevel* c )
|
|
{
|
|
assert( !window_data.contains( c ));
|
|
resetWindowData( c );
|
|
}
|
|
|
|
// TODO handle xrandr changes
|
|
|
|
void SceneXrender::createBuffer()
|
|
{
|
|
if( buffer != None )
|
|
XRenderFreePicture( display(), buffer );
|
|
Pixmap pixmap = XCreatePixmap( display(), rootWindow(), displayWidth(), displayHeight(), QX11Info::appDepth());
|
|
buffer = XRenderCreatePicture( display(), pixmap, format, 0, 0 );
|
|
XFreePixmap( display(), pixmap ); // The picture owns the pixmap now
|
|
}
|
|
|
|
void SceneXrender::setPictureMatrix( Picture pic, const Matrix& )
|
|
{
|
|
if( pic == None )
|
|
return;
|
|
#if 0
|
|
XTransform t;
|
|
// ignore z axis
|
|
t.matrix[ 0 ][ 0 ] = XDoubleToFixed( 1 / m.m[ 0 ][ 0 ] );
|
|
t.matrix[ 0 ][ 1 ] = XDoubleToFixed( m.m[ 0 ][ 1 ] );
|
|
t.matrix[ 0 ][ 2 ] = -XDoubleToFixed( m.m[ 0 ][ 3 ] ); // translation seems to be inverted
|
|
t.matrix[ 1 ][ 0 ] = XDoubleToFixed( m.m[ 1 ][ 0 ] );
|
|
t.matrix[ 1 ][ 1 ] = XDoubleToFixed( 1 / m.m[ 1 ][ 1 ] );
|
|
t.matrix[ 1 ][ 2 ] = -XDoubleToFixed( m.m[ 1 ][ 3 ] );
|
|
t.matrix[ 2 ][ 0 ] = XDoubleToFixed( m.m[ 3 ][ 0 ] );
|
|
t.matrix[ 2 ][ 1 ] = XDoubleToFixed( m.m[ 3 ][ 1 ] );
|
|
t.matrix[ 2 ][ 2 ] = XDoubleToFixed( m.m[ 3 ][ 3 ] );
|
|
// and scaling seems to be wrong too
|
|
// or maybe I just don't get it, but anyway, for now
|
|
if( m.m[ 3 ][ 3 ] != 1 )
|
|
{
|
|
t.matrix[ 0 ][ 0 ] = XDoubleToFixed( 1 / m.m[ 0 ][ 0 ] * m.m[ 3 ][ 3 ] );
|
|
t.matrix[ 1 ][ 1 ] = XDoubleToFixed( 1 / m.m[ 1 ][ 1 ] * m.m[ 3 ][ 3 ] );
|
|
t.matrix[ 2 ][ 2 ] = XDoubleToFixed( 1 );
|
|
}
|
|
XRenderSetPictureTransform( display(), pic, &t );
|
|
if( t.matrix[ 0 ][ 0 ] != XDoubleToFixed( 1 )
|
|
|| t.matrix[ 1 ][ 1 ] != XDoubleToFixed( 1 )
|
|
|| t.matrix[ 2 ][ 2 ] != XDoubleToFixed( 1 )
|
|
|| t.matrix[ 0 ][ 1 ] != XDoubleToFixed( 0 )
|
|
|| t.matrix[ 1 ][ 0 ] != XDoubleToFixed( 0 ))
|
|
{
|
|
XRenderSetPictureFilter( display(), pic, const_cast< char* >( FilterGood ), 0, 0 );
|
|
}
|
|
else // fast filter for identity or translation
|
|
{
|
|
XRenderSetPictureFilter( display(), pic, const_cast< char* >( FilterFast ), 0, 0 );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
SceneXrender::WindowData::WindowData( Toplevel* c, XRenderPictFormat* f )
|
|
: window( c )
|
|
, _picture( None )
|
|
, format( f )
|
|
, saved_clip_region( None )
|
|
, alpha( None )
|
|
, _shape( None )
|
|
{
|
|
}
|
|
|
|
void SceneXrender::WindowData::free()
|
|
{
|
|
if( _picture != None )
|
|
XRenderFreePicture( display(), _picture );
|
|
if( alpha != None )
|
|
XRenderFreePicture( display(), alpha );
|
|
if( _shape != None )
|
|
XRenderFreePicture( display(), _shape );
|
|
}
|
|
|
|
bool SceneXrender::WindowData::simpleTransformation() const
|
|
{
|
|
return ( matrix.isIdentity() || matrix.isOnlyTranslate());
|
|
}
|
|
|
|
Picture SceneXrender::WindowData::picture()
|
|
{
|
|
if( !window->damage().isEmpty() && _picture != None )
|
|
{
|
|
XRenderFreePicture( display(), _picture );
|
|
_picture = None;
|
|
}
|
|
if( _picture == None && format != NULL )
|
|
{
|
|
Pixmap window_pix = window->createWindowPixmap();
|
|
Pixmap pix = window_pix;
|
|
// HACK the same like with opengl
|
|
Client* c = dynamic_cast< Client* >( window );
|
|
bool alpha_clear = c != NULL && c->hasAlpha() && !c->noBorder();
|
|
#define ALPHA_CLEAR_COPY
|
|
#ifdef ALPHA_CLEAR_COPY
|
|
if( alpha_clear )
|
|
{
|
|
Pixmap p2 = XCreatePixmap( display(), pix, c->width(), c->height(), 32 );
|
|
GC gc = XCreateGC( display(), pix, 0, NULL );
|
|
XCopyArea( display(), pix, p2, gc, 0, 0, c->width(), c->height(), 0, 0 );
|
|
pix = p2;
|
|
XFreeGC( display(), gc );
|
|
}
|
|
#endif
|
|
if( alpha_clear )
|
|
{
|
|
XGCValues gcv;
|
|
gcv.foreground = 0xff000000;
|
|
gcv.plane_mask = 0xff000000;
|
|
GC gc = XCreateGC( display(), pix, GCPlaneMask | GCForeground, &gcv );
|
|
XFillRectangle( display(), pix, gc, 0, 0, c->width(), c->clientPos().y());
|
|
XFillRectangle( display(), pix, gc, 0, 0, c->clientPos().x(), c->height());
|
|
int tw = c->clientPos().x() + c->clientSize().width();
|
|
int th = c->clientPos().y() + c->clientSize().height();
|
|
XFillRectangle( display(), pix, gc, 0, th, c->width(), c->height() - th );
|
|
XFillRectangle( display(), pix, gc, tw, 0, c->width() - tw, c->height());
|
|
XFreeGC( display(), gc );
|
|
}
|
|
_picture = XRenderCreatePicture( display(), pix, format, 0, 0 );
|
|
XFreePixmap( display(), pix ); // the picture owns the pixmap
|
|
#ifdef ALPHA_CLEAR_COPY
|
|
if( alpha_clear )
|
|
XFreePixmap( display(), window_pix );
|
|
#endif
|
|
}
|
|
return _picture;
|
|
}
|
|
|
|
void SceneXrender::WindowData::saveClipRegion( XserverRegion r )
|
|
{
|
|
saved_clip_region = XFixesCreateRegion( display(), NULL, 0 );
|
|
XFixesCopyRegion( display(), saved_clip_region, r );
|
|
}
|
|
|
|
XserverRegion SceneXrender::WindowData::savedClipRegion()
|
|
{
|
|
return saved_clip_region;
|
|
}
|
|
|
|
void SceneXrender::WindowData::cleanup()
|
|
{
|
|
XFixesDestroyRegion( display(), saved_clip_region );
|
|
saved_clip_region = None;
|
|
}
|
|
|
|
bool SceneXrender::WindowData::isOpaque() const
|
|
{
|
|
if( format->type == PictTypeDirect && format->direct.alphaMask )
|
|
return false;
|
|
if( effect.opacity != 1.0 )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
Picture SceneXrender::WindowData::alphaMask()
|
|
{
|
|
if( isOpaque())
|
|
return None;
|
|
if( alpha != None && alpha_cached_opacity != effect.opacity )
|
|
{
|
|
if( alpha != None )
|
|
XRenderFreePicture( display(), alpha );
|
|
alpha = None;
|
|
}
|
|
if( alpha != None )
|
|
return alpha;
|
|
if( effect.opacity == 1.0 )
|
|
{ // no need to create alpha mask
|
|
alpha_cached_opacity = 1.0;
|
|
return None;
|
|
}
|
|
Pixmap pixmap = XCreatePixmap( display(), rootWindow(), 1, 1, 8 );
|
|
XRenderPictFormat* format = XRenderFindStandardFormat( display(), PictStandardA8 );
|
|
XRenderPictureAttributes pa;
|
|
pa.repeat = True;
|
|
alpha = XRenderCreatePicture( display(), pixmap, format, CPRepeat, &pa );
|
|
XFreePixmap( display(), pixmap );
|
|
XRenderColor col;
|
|
col.alpha = int( effect.opacity * 0xffff );
|
|
alpha_cached_opacity = effect.opacity;
|
|
XRenderFillRectangle( display(), PictOpSrc, alpha, &col, 0, 0, 1, 1 );
|
|
return alpha;
|
|
}
|
|
|
|
|
|
XserverRegion SceneXrender::WindowData::shape()
|
|
{
|
|
#if 0 // it probably doesn't make sense to cache this, and perhaps some others - they aren't roundtrips
|
|
if( shape == None )
|
|
{
|
|
shape = XFixesCreateRegionFromWindow( display(), window->handle(), WindowRegionBounding );
|
|
XFixesTranslateRegion( display(), shape, window->x(), window->y());
|
|
}
|
|
return shape;
|
|
#else
|
|
if( !simpleTransformation())
|
|
{
|
|
// The region here should be translated using the matrix, but that's not possible
|
|
// (well, maybe fetch the region and transform manually - TODO check).
|
|
return None;
|
|
}
|
|
XserverRegion shape = XFixesCreateRegionFromWindow( display(), window->handle(), WindowRegionBounding );
|
|
XFixesTranslateRegion( display(), shape,
|
|
window->x() + int( matrix.xTranslate()), window->y() + int( matrix.yTranslate()));
|
|
return shape;
|
|
#endif
|
|
}
|
|
|
|
void SceneXrender::WindowData::geometryShapeChanged()
|
|
{
|
|
if( _picture != None )
|
|
XRenderFreePicture( display(), _picture );
|
|
_picture = None;
|
|
if( alpha != None )
|
|
XRenderFreePicture( display(), alpha );
|
|
alpha = None;
|
|
if( _shape != None )
|
|
XFixesDestroyRegion( display(), _shape );
|
|
_shape = None;
|
|
}
|
|
|
|
void SceneXrender::WindowData::opacityChanged()
|
|
{
|
|
if( alpha != None )
|
|
XRenderFreePicture( display(), alpha );
|
|
alpha = None;
|
|
}
|
|
|
|
} // namespace
|
|
#endif
|