kwin/clients/oxygen/oxygenshadowcache.h
Hugo Pereira Da Costa c5bf8d012e Changed all "Oxygen::OxygenXXX" classnames into "Oxygen::XXX" for consistancy with style class
naming scheme. Also made indentation consistent.

svn path=/trunk/KDE/kdebase/workspace/; revision=1121935
2010-05-02 18:34:08 +00:00

233 lines
6.8 KiB
C++

#ifndef oxygenshadowcache_h
#define oxygenshadowcache_h
//////////////////////////////////////////////////////////////////////////////
// oxygenshadowcache.h
// handles caching of TileSet objects to draw shadows
// -------------------
//
// Copyright (c) 2009 Hugo Pereira Da Costa <hugo.pereira@free.fr>
//
// 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.
//////////////////////////////////////////////////////////////////////////////
#include <QtCore/QCache>
#include <QtGui/QRadialGradient>
#include "oxygenshadowconfiguration.h"
#include "helper.h"
class OxygenHelper;
namespace Oxygen
{
class Client;
class ShadowCache
{
public:
//! constructor
ShadowCache( OxygenDecoHelper& helper );
//! destructor
virtual ~ShadowCache( void )
{}
//! cache size
void setEnabled( bool enabled )
{
enabled_ = enabled;
if( enabled )
{
shadowCache_.setMaxCost( 1<<6 );
animatedShadowCache_.setMaxCost( maxIndex_<<6 );
} else {
shadowCache_.setMaxCost( 1 );
animatedShadowCache_.setMaxCost( 1 );
}
}
//! max animation index
int maxIndex( void ) const
{ return maxIndex_; }
//! max animation index
void setMaxIndex( int value )
{
maxIndex_ = value;
if( enabled_ )
{
shadowCache_.setMaxCost( 1<<6 );
animatedShadowCache_.setMaxCost( maxIndex_<<6 );
}
}
//! invalidate caches
void invalidateCaches( void )
{
shadowCache_.clear();
animatedShadowCache_.clear();
}
//! returns true if provided shadow configuration changes with respect to stored
/*!
use ShadowConfiguration::colorRole() to decide whether it should be stored
as active or inactive
*/
bool shadowConfigurationChanged( const ShadowConfiguration& ) const;
//! set shadowConfiguration
/*!
use ShadowConfiguration::colorRole() to decide whether it should be stored
as active or inactive
*/
void setShadowConfiguration( const ShadowConfiguration& );
//! shadow size
qreal shadowSize( void ) const
{
qreal activeSize( activeShadowConfiguration_.isEnabled() ? activeShadowConfiguration_.shadowSize():0 );
qreal inactiveSize( inactiveShadowConfiguration_.isEnabled() ? inactiveShadowConfiguration_.shadowSize():0 );
qreal size( qMax( activeSize, inactiveSize ) );
// even if shadows are disabled,
// you need a minimum size to allow corner rendering
return qMax( size, qreal(5.0) );
}
//! get shadow matching client
TileSet* tileSet( const Client* );
//! get shadow matching client and opacity
TileSet* tileSet( const Client*, qreal );
//! Key class to be used into QCache
/*! class is entirely inline for optimization */
class Key
{
public:
//! explicit constructor
explicit Key( void ):
index(0),
active(false),
useOxygenShadows(false),
isShade(false),
hasTitleOutline(false),
hasBorder( true )
{}
//! constructor from client
Key( const Client* );
//! constructor from int
Key( int hash ):
index( hash>>5 ),
active( (hash>>4)&1 ),
useOxygenShadows( (hash>>3)&1 ),
isShade( (hash>>2)&1 ),
hasTitleOutline( (hash>>1)&1 ),
hasBorder( hash&1 )
{}
//! hash function
int hash( void ) const
{
// note this can be optimized because not all of the flag configurations are actually relevant
// allocate 3 empty bits for flags
return
( index << 5 ) |
( active << 4 ) |
(useOxygenShadows << 3 ) |
(isShade<<2) |
(hasTitleOutline<<1) |
(hasBorder<<0);
}
int index;
bool active;
bool useOxygenShadows;
bool isShade;
bool hasTitleOutline;
bool hasBorder;
};
//! complex pixmap (when needed)
QPixmap shadowPixmap( const Client*, bool active ) const;
//! simple pixmap
QPixmap simpleShadowPixmap( const QColor& color, const Key& key ) const
{ return simpleShadowPixmap( color, key, key.active ); }
//! simple pixmap
QPixmap simpleShadowPixmap( const QColor&, const Key&, bool active ) const;
protected:
OxygenHelper& helper( void ) const
{ return helper_; }
private:
//! draw gradient into rect
/*! a separate method is used in order to properly account for corners */
void renderGradient( QPainter&, const QRectF&, const QRadialGradient&, bool hasBorder = true ) const;
//! helper
OxygenDecoHelper& helper_;
//! caching enable state
bool enabled_;
//! max index
/*! it is used to set caches max cost, and calculate animation opacity */
int maxIndex_;
//! shadow configuration
ShadowConfiguration activeShadowConfiguration_;
//! shadow configuration
ShadowConfiguration inactiveShadowConfiguration_;
//! cache
typedef QCache<int, TileSet> TileSetCache;
//! shadow cache
TileSetCache shadowCache_;
//! animated shadow cache
TileSetCache animatedShadowCache_;
};
}
#endif