use the new Config::hasGroup method instead of a custom Config class

1 files changed, 1 insertions, 13 deletions

diff --git a/noncore/styles/theme/othemebase.cpp b/noncore/styles/theme/othemebase.cpp
index acac847..62b3a11 100644
--- a/noncore/styles/theme/othemebase.cpp
+++ b/noncore/styles/theme/othemebase.cpp
@@ -1,787 +1,775 @@
 /* This file is part of the KDE libraries
   Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
 */
 #include "othemebase.h"
 #include "ogfxeffect.h"
 #include <qpe/qpeapplication.h> 
 //#include <kdebug.h>
 //#include <klocale.h>
 #include <qpe/config.h> 
 //#include <kglobal.h>
 //#include <kglobalsettings.h>
 //#include <kstddirs.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qdir.h>
 #include <qpainter.h>
 #include <qbitmap.h>
 #include <stdlib.h> 
 #include <qstringlist.h>
 
 #include <stdio.h>
 
 
 template class QIntCache<OThemePixmap>
 ;
 
 static const char *widgetEntries[] =
     { // unsunken widgets (see header)
         "PushButton", "ComboBox", "HSBarSlider", "VSBarSlider", "Bevel", "ToolButton",
         "ScrollButton", "HScrollDeco", "VScrollDeco", "ComboDeco", "MenuItem", "Tab",
         "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight",
         // sunken widgets
         "PushButtonDown", "ComboBoxDown", "HSBarSliderDown", "VSBarSliderDown",
         "BevelDown", "ToolButtonDown", "ScrollButtonDown", "HScrollDecoDown",
         "VScrollDecoDown", "ComboDecoDown", "MenuItemDown", "TabDown", "SunkenArrowUp",
         "SunkenArrowDown", "SunkenArrowLeft", "SunkenArrowRight",
         // everything else
         "HScrollGroove", "VScrollGroove", "Slider", "SliderGroove", "CheckBoxDown",
         "CheckBox", "RadioDown", "Radio", "HBarHandle", "VBarHandle",
         "ToolBar", "Splitter", "CheckMark", "MenuBar", "DisableArrowUp",
         "DisableArrowDown", "DisableArrowLeft", "DisableArrowRight", "ProgressBar",
         "ProgressBackground", "MenuBarItem", "Background"
     };
 
 #define INHERIT_ITEMS 16
 
 
 // This is used to encode the keys. I used to use masks but I think this
 // bitfield is nicer :) I don't know why C++ coders don't use these more..
 // (mosfet)
 struct kthemeKeyData
 {
 unsigned int id :
 	6;
 unsigned int width :
 	12;
 unsigned int height :
 	12;
 unsigned int border :
 	1;
 unsigned int mask :
 	1;
 };
 
 union kthemeKey{
 	kthemeKeyData data;
 	unsigned int cacheKey;
 };
 
-class MyConfig : public Config
-{
-public:
-	MyConfig ( const QString &f, Domain d ) : Config ( f, d )
-	{ }
-
-	bool hasGroup ( const QString &gname ) const
-	{
-		QMap< QString, ConfigGroup>::ConstIterator it = groups. find ( gname );
-		return ( it != groups.end() );
-	}
-};
 
 void OThemeBase::generateBorderPix( int i )
 {
 	// separate pixmap into separate components
 	if ( pbPixmaps[ i ] ) {
 		// evidently I have to do masks manually...
 		const QBitmap * srcMask = pbPixmaps[ i ] ->mask();
 		QBitmap destMask( pbWidth[ i ], pbWidth[ i ] );
 		QPixmap tmp( pbWidth[ i ], pbWidth[ i ] );
 
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], 0, 0, pbWidth[ i ], pbWidth[ i ],
 		        Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, 0, 0, pbWidth[ i ], pbWidth[ i ],
 			        Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::TopLeft, tmp );
 
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], pbPixmaps[ i ] ->width() - pbWidth[ i ], 0,
 		        pbWidth[ i ], pbWidth[ i ], Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, pbPixmaps[ i ] ->width() - pbWidth[ i ],
 			        0, pbWidth[ i ], pbWidth[ i ], Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::TopRight, tmp );
 
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], 0, pbPixmaps[ i ] ->height() - pbWidth[ i ],
 		        pbWidth[ i ], pbWidth[ i ], Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, 0, pbPixmaps[ i ] ->height() - pbWidth[ i ],
 			        pbWidth[ i ], pbWidth[ i ], Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::BottomLeft, tmp );
 
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], pbPixmaps[ i ] ->width() - pbWidth[ i ],
 		        pbPixmaps[ i ] ->height() - pbWidth[ i ], pbWidth[ i ], pbWidth[ i ],
 		        Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, pbPixmaps[ i ] ->width() - pbWidth[ i ],
 			        pbPixmaps[ i ] ->height() - pbWidth[ i ], pbWidth[ i ], pbWidth[ i ],
 			        Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::BottomRight, tmp );
 
 		tmp.resize( pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ] );
 		destMask.resize( pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ] );
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], pbWidth[ i ], 0,
 		        pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, pbWidth[ i ], 0,
 			        pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ],
 			        Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::Top, tmp );
 
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], pbWidth[ i ],
 		        pbPixmaps[ i ] ->height() - pbWidth[ i ],
 		        pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, pbWidth[ i ],
 			        pbPixmaps[ i ] ->height() - pbWidth[ i ],
 			        pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::Bottom, tmp );
 
 		tmp.resize( pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2 );
 		destMask.resize( pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2 );
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], 0, pbWidth[ i ], pbWidth[ i ],
 		        pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2, Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, 0, pbWidth[ i ], pbWidth[ i ],
 			        pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2, Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::Left, tmp );
 
 		bitBlt( &tmp, 0, 0, pbPixmaps[ i ], pbPixmaps[ i ] ->width() - pbWidth[ i ],
 		        pbWidth[ i ], pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2,
 		        Qt::CopyROP, false );
 		if ( srcMask ) {
 			bitBlt( &destMask, 0, 0, srcMask, pbPixmaps[ i ] ->width() - pbWidth[ i ],
 			        pbWidth[ i ], pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2,
 			        Qt::CopyROP, false );
 			tmp.setMask( destMask );
 		}
 		pbPixmaps[ i ] ->setBorder( OThemePixmap::Right, tmp );
 	}
 	else
 		qDebug ( "OThemeBase: Tried making border from empty pixmap" );
 }
 
 
 void OThemeBase::copyWidgetConfig( int sourceID, int destID, QString *pixnames,
                                    QString *brdnames )
 {
 	scaleHints[ destID ] = scaleHints[ sourceID ];
 	gradients[ destID ] = gradients[ sourceID ];
 	blends[ destID ] = blends[ sourceID ];
 	bContrasts[ destID ] = bContrasts[ sourceID ];
 	borders[ destID ] = borders[ sourceID ];
 	highlights[ destID ] = highlights[ sourceID ];
 
 	if ( grLowColors[ sourceID ] )
 		grLowColors[ destID ] = new QColor( *grLowColors[ sourceID ] );
 	else
 		grLowColors[ destID ] = NULL;
 
 	if ( grHighColors[ sourceID ] )
 		grHighColors[ destID ] = new QColor( *grHighColors[ sourceID ] );
 	else
 		grHighColors[ destID ] = NULL;
 
 	if ( colors[ sourceID ] )
 		colors[ destID ] = new QColorGroup( *colors[ sourceID ] );
 	else
 		colors[ destID ] = NULL;
 
 	// pixmap
 	pixnames[ destID ] = pixnames[ sourceID ];
 	duplicate[ destID ] = false;
 	pixmaps[ destID ] = NULL;
 	images[ destID ] = NULL;
 	if ( !pixnames[ destID ].isEmpty() ) {
 		if ( scaleHints[ sourceID ] == TileScale && blends[ sourceID ] == 0.0 ) {
 			pixmaps[ destID ] = pixmaps[ sourceID ];
 			duplicate[ destID ] = true;
 		}
 		if ( !duplicate[ destID ] ) {
 			pixmaps[ destID ] = loadPixmap( pixnames[ destID ] );
 			if ( scaleHints[ destID ] == TileScale && blends[ destID ] == 0.0 )
 				images[ destID ] = NULL;
 			else
 				images[ destID ] = loadImage( pixnames[ destID ] );
 		}
 	}
 
 	// border pixmap
 	pbDuplicate[ destID ] = false;
 	pbPixmaps[ destID ] = NULL;
 	pbWidth[ destID ] = pbWidth[ sourceID ];
 	brdnames[ destID ] = brdnames[ sourceID ];
 	if ( !brdnames[ destID ].isEmpty() ) {
 		pbPixmaps[ destID ] = pbPixmaps[ sourceID ];
 		pbDuplicate[ destID ] = true;
 	}
 
 	if ( sourceID == ActiveTab && destID == InactiveTab )
 		aTabLine = iTabLine;
 	else if ( sourceID == InactiveTab && destID == ActiveTab )
 		iTabLine = aTabLine;
 }
 
 void OThemeBase::readConfig( Qt::GUIStyle /*style*/ )
 {
 #define PREBLEND_ITEMS 12
 	static WidgetType preBlend[] = {Slider, IndicatorOn, IndicatorOff,
 	                                ExIndicatorOn, ExIndicatorOff, HScrollDeco, VScrollDeco, HScrollDecoDown,
 	                                VScrollDecoDown, ComboDeco, ComboDecoDown, CheckMark};
 
 	int i;
 	QString tmpStr;
 	QString copyfrom[ WIDGETS ];
 	QString pixnames[ WIDGETS ]; // used for duplicate check
 	QString brdnames[ WIDGETS ];
 	bool loaded[ WIDGETS ]; // used for preloading for CopyWidget
 
 	if ( configFileName.isEmpty() ) {
 		Config cfg ( "qpe" );
 		cfg. setGroup ( "Appearance" );
 	
 		configFileName = cfg. readEntry ( "Theme", "default" );
 	}
-	MyConfig config( configFilePath + "/themes/" + configFileName + ".themerc" , Config::File );
+	Config config( configFilePath + "/themes/" + configFileName + ".themerc" , Config::File );
 
 //	printf ( "Opened config file: %s\n", ( configFilePath + "/themes/" + configFileName + ".themerc" ). ascii());
 
 	// Are we initalized?
 	applyMiscResourceGroup( &config );
 	for ( i = 0; i < INHERIT_ITEMS; ++i ) {
 		applyResourceGroup( &config, i, copyfrom, pixnames, brdnames );		
 //		printf ( "%d [%s]: copy=%s, pix=%s, brd=%s\n", i, widgetEntries [i], copyfrom [i].latin1(), pixnames[i].latin1(),brdnames[i].latin1() );
 	}
 	for ( ; i < INHERIT_ITEMS*2; ++i ) {
 		if ( config.hasGroup( QString( widgetEntries[ i ] ) ) ) {
 			applyResourceGroup( &config, i, copyfrom, pixnames, brdnames );
 //			printf ( "%d [%s]: copy=%s, pix=%s, brd=%s\n", i, widgetEntries [i], copyfrom [i].latin1(), pixnames[i].latin1(),brdnames[i].latin1() );
 		}
 		else {
 			copyfrom [ i ] = widgetEntries[ i - INHERIT_ITEMS ];
 //			printf ( "%d [%s]: copy=%s\n", i, widgetEntries [i], copyfrom [i].latin1());
 		}
 	}
 	for ( ; i < WIDGETS; ++i ) {
 		applyResourceGroup( &config, i, copyfrom, pixnames, brdnames );
 //		printf ( "%d [%s]: copy=%s, pix=%s, brd=%s\n", i, widgetEntries [i], copyfrom [i].latin1(), pixnames[i].latin1(),brdnames[i].latin1() );
 	}
 
 	// initalize defaults that may not be read
 	for ( i = 0; i < WIDGETS; ++i )
 		loaded[ i ] = false;
 	btnXShift = btnYShift = focus3DOffset = 0;
 	aTabLine = iTabLine = true;
 	roundedButton = roundedCombo = roundedSlider = focus3D = false;
 	splitterWidth = 10;
 
 	for ( i = 0; i < WIDGETS; ++i ) {
 		readResourceGroup( i, copyfrom, pixnames, brdnames, loaded );
 //		printf ( "%d [%s]: copy=%s, pix=%s, brd=%s, colors=%s\n", i, widgetEntries [i], copyfrom [i].latin1(), pixnames[i].latin1(),brdnames[i].latin1(), (colors[i]?colors[i]->background().name().latin1():"<none)" ));
 	}
 
 	// misc items
 	readMiscResourceGroup();
 
 	// Handle preblend items
 	for ( i = 0; i < PREBLEND_ITEMS; ++i ) {
 		if ( pixmaps[ preBlend[ i ] ] != NULL && blends[ preBlend[ i ] ] != 0.0 )
 			blend( preBlend[ i ] );
 	}
 }
 
 OThemeBase::OThemeBase( const QString & configFile )
 		: QWindowsStyle()
 {
 	configFilePath = QPEApplication::qpeDir ( ) + "/plugins/styles/";
 	configFileName = configFile;
 
 	readConfig( Qt::WindowsStyle );
 	cache = new OThemeCache( cacheSize );
 }
 
 void OThemeBase::applyConfigFile( const QString &/*file*/ )
 {
 #if 0
 	// handle std color scheme
 	Config inConfig( file, Config::File );
 	Config globalConfig ( "qpe" );
 	
 	globalConfig. setGroup ( "Apperance" );
 	inConfig. setGroup( "General" );
 	
 	if ( inConfig.hasKey( "foreground" ) )
 		globalConfig.writeEntry( "Text",                    inConfig.readEntry( "foreground", " " ) );
 	if ( inConfig.hasKey( "background" ) )
 		globalConfig.writeEntry( "Background",                    inConfig.readEntry( "background", " " ) );
 	if ( inConfig.hasKey( "selectForeground" ) )
 		globalConfig.writeEntry( "HighlightedText",              inConfig.readEntry( "selectForeground", " " ) );
 	if ( inConfig.hasKey( "selectBackground" ) )
 		globalConfig.writeEntry( "Highlight",                     inConfig.readEntry( "selectBackground", " " ) );
 	if ( inConfig.hasKey( "windowForeground" ) )
 		globalConfig.writeEntry( "Text",              inConfig.readEntry( "windowForeground", " " ) );
 	if ( inConfig.hasKey( "windowBackground" ) )
 		globalConfig.writeEntry( "Base",              inConfig.readEntry( "windowBackground", " " ) );
 
 	// Keep track of the current theme so that we can select the right one
 	// in the KControl module.
 	globalConfig.writeEntry ( "CurrentTheme", file );
 
 	globalConfig.write();
 #endif
 }
 
 OThemeBase::~OThemeBase()
 {
 	int i;
 	for ( i = 0; i < WIDGETS; ++i ) {
 		if ( !duplicate[ i ] ) {
 			if ( images[ i ] )
 				delete images[ i ];
 			if ( pixmaps[ i ] )
 				delete pixmaps[ i ];
 		}
 		if ( !pbDuplicate[ i ] && pbPixmaps[ i ] )
 			delete pbPixmaps[ i ];
 		if ( colors[ i ] )
 			delete( colors[ i ] );
 		if ( grLowColors[ i ] )
 			delete( grLowColors[ i ] );
 		if ( grHighColors[ i ] )
 			delete( grHighColors[ i ] );
 	}
 	delete cache;
 }
 
 QImage* OThemeBase::loadImage( QString &name )
 {
 	QImage * image = new QImage;
 	QString path = configFilePath + "/pixmaps/" + name;
 	image->load( path );
 	if ( !image->isNull() )
 		return ( image );
 	qDebug ( "OThemeBase: Unable to load image %s\n", name.ascii ( ) );
 	delete image;
 	return ( NULL );
 }
 
 OThemePixmap* OThemeBase::loadPixmap( QString &name )
 {
 	OThemePixmap * pixmap = new OThemePixmap( false );
 	QString path = configFilePath + "/pixmaps/" + name;
 	pixmap->load( path );
 	if ( !pixmap->isNull() )
 		return pixmap;
 	qDebug ( "OThemeBase: Unable to load pixmap %s\n", name.ascii() );
 	delete pixmap;
 	return ( NULL );
 }
 
 OThemePixmap* OThemeBase::scale( int w, int h, WidgetType widget )
 {
 	if ( scaleHints[ widget ] == FullScale ) {
 		if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
 		        pixmaps[ widget ] ->height() != h ) {
 			OThemePixmap * cachePix = cache->pixmap( w, h, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::FullScale,
 					               widget );
 				else
 					qDebug( "We would have inserted a null pixmap!\n" );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				cache->insert( pixmaps[ widget ], OThemeCache::FullScale, widget );
 				QImage tmpImg = images[ widget ] ->smoothScale( w, h );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->convertFromImage( tmpImg );
 				if ( blends[ widget ] != 0.0 )
 					blend( widget );
 			}
 		}
 	}
 	else if ( scaleHints[ widget ] == HorizontalScale ) {
 		if ( pixmaps[ widget ] ->width() != w ) {
 			OThemePixmap * cachePix = cache->horizontalPixmap( w, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::HorizontalScale, widget );
 				else
 					qDebug ( "We would have inserted a null pixmap!\n" );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				cache->insert( pixmaps[ widget ], OThemeCache::HorizontalScale, widget );
 				QImage tmpImg = images[ widget ] ->
 				                smoothScale( w, images[ widget ] ->height() );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->convertFromImage( tmpImg );
 				if ( blends[ widget ] != 0.0 )
 					blend( widget );
 			}
 		}
 	}
 	else if ( scaleHints[ widget ] == VerticalScale ) {
 		if ( pixmaps[ widget ] ->height() != h ) {
 			OThemePixmap * cachePix = cache->verticalPixmap( w, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::VerticalScale, widget );
 				else
 					qDebug ( "We would have inserted a null pixmap!\n" );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				cache->insert( pixmaps[ widget ], OThemeCache::VerticalScale, widget );
 				QImage tmpImg =
 				    images[ widget ] ->smoothScale( images[ widget ] ->width(), h );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->convertFromImage( tmpImg );
 				if ( blends[ widget ] != 0.0 )
 					blend( widget );
 			}
 		}
 	}
 	// If blended tile here so the blend is scaled properly
 	else if ( scaleHints[ widget ] == TileScale && blends[ widget ] != 0.0 ) {
 		if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
 		        pixmaps[ widget ] ->height() != h ) {
 			OThemePixmap * cachePix = cache->pixmap( w, h, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				cache->insert( pixmaps[ widget ], OThemeCache::FullScale, widget );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				cache->insert( pixmaps[ widget ], OThemeCache::FullScale, widget );
 				QPixmap tile;
 				tile.convertFromImage( *images[ widget ] );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->resize( w, h );
 				QPainter p( pixmaps[ widget ] );
 				p.drawTiledPixmap( 0, 0, w, h, tile );
 				if ( blends[ widget ] != 0.0 )
 					blend( widget );
 			}
 		}
 	}
 	return ( pixmaps[ widget ] );
 }
 
 OThemePixmap* OThemeBase::scaleBorder( int w, int h, WidgetType widget )
 {
 	OThemePixmap * pixmap = NULL;
 	if ( !pbPixmaps[ widget ] && !pbWidth[ widget ] )
 		return ( NULL );
 	pixmap = cache->pixmap( w, h, widget, true );
 	if ( pixmap ) {
 		pixmap = new OThemePixmap( *pixmap );
 	}
 	else {
 		pixmap = new OThemePixmap();
 		pixmap->resize( w, h );
 		QBitmap mask;
 		mask.resize( w, h );
 		mask.fill( color0 );
 		QPainter mPainter;
 		mPainter.begin( &mask );
 
 		QPixmap *tmp = borderPixmap( widget ) ->border( OThemePixmap::TopLeft );
 		const QBitmap *srcMask = tmp->mask();
 		int bdWidth = tmp->width();
 
 		bitBlt( pixmap, 0, 0, tmp, 0, 0, bdWidth, bdWidth,
 		        Qt::CopyROP, false );
 		if ( srcMask )
 			bitBlt( &mask, 0, 0, srcMask, 0, 0, bdWidth, bdWidth,
 			        Qt::CopyROP, false );
 		else
 			mPainter.fillRect( 0, 0, bdWidth, bdWidth, color1 );
 
 
 		tmp = borderPixmap( widget ) ->border( OThemePixmap::TopRight );
 		srcMask = tmp->mask();
 		bitBlt( pixmap, w - bdWidth, 0, tmp, 0, 0, bdWidth,
 		        bdWidth, Qt::CopyROP, false );
 		if ( srcMask )
 			bitBlt( &mask, w - bdWidth, 0, srcMask, 0, 0, bdWidth,
 			        bdWidth, Qt::CopyROP, false );
 		else
 			mPainter.fillRect( w - bdWidth, 0, bdWidth, bdWidth, color1 );
 
 		tmp = borderPixmap( widget ) ->border( OThemePixmap::BottomLeft );
 		srcMask = tmp->mask();
 		bitBlt( pixmap, 0, h - bdWidth, tmp, 0, 0, bdWidth,
 		        bdWidth, Qt::CopyROP, false );
 		if ( srcMask )
 			bitBlt( &mask, 0, h - bdWidth, srcMask, 0, 0, bdWidth,
 			        bdWidth, Qt::CopyROP, false );
 		else
 			mPainter.fillRect( 0, h - bdWidth, bdWidth, bdWidth, color1 );
 
 		tmp = borderPixmap( widget ) ->border( OThemePixmap::BottomRight );
 		srcMask = tmp->mask();
 		bitBlt( pixmap, w - bdWidth, h - bdWidth, tmp, 0, 0,
 		        bdWidth, bdWidth, Qt::CopyROP, false );
 		if ( srcMask )
 			bitBlt( &mask, w - bdWidth, h - bdWidth, srcMask, 0, 0,
 			        bdWidth, bdWidth, Qt::CopyROP, false );
 		else
 			mPainter.fillRect( w - bdWidth, h - bdWidth, bdWidth, bdWidth, color1 );
 
 		QPainter p;
 		p.begin( pixmap );
 		if ( w - bdWidth * 2 > 0 ) {
 			tmp = borderPixmap( widget ) ->border( OThemePixmap::Top );
 			srcMask = tmp->mask();
 			p.drawTiledPixmap( bdWidth, 0, w - bdWidth * 2, bdWidth, *tmp );
 			if ( srcMask )
 				mPainter.drawTiledPixmap( bdWidth, 0, w - bdWidth * 2, bdWidth, *srcMask );
 			else
 				mPainter.fillRect( bdWidth, 0, w - bdWidth * 2, bdWidth, color1 );
 
 			tmp = borderPixmap( widget ) ->border( OThemePixmap::Bottom );
 			srcMask = tmp->mask();
 			p.drawTiledPixmap( bdWidth, h - bdWidth, w - bdWidth * 2, bdWidth,
 			                   *tmp );
 			if ( srcMask )
 				mPainter.drawTiledPixmap( bdWidth, h - bdWidth, w - bdWidth * 2, bdWidth, *srcMask );
 			else
 				mPainter.fillRect( bdWidth, h - bdWidth, w - bdWidth * 2, bdWidth,
 				                   color1 );
 		}
 		if ( h - bdWidth * 2 > 0 ) {
 			tmp = borderPixmap( widget ) ->border( OThemePixmap::Left );
 			srcMask = tmp->mask();
 			p.drawTiledPixmap( 0, bdWidth, bdWidth, h - bdWidth * 2, *tmp );
 			if ( srcMask )
 				mPainter.drawTiledPixmap( 0, bdWidth, bdWidth, h - bdWidth * 2, *srcMask );
 			else
 				mPainter.fillRect( 0, bdWidth, bdWidth, h - bdWidth * 2, color1 );
 
 			tmp = borderPixmap( widget ) ->border( OThemePixmap::Right );
 			srcMask = tmp->mask();
 			p.drawTiledPixmap( w - bdWidth, bdWidth, bdWidth, h - bdWidth * 2,
 			                   *tmp );
 			if ( srcMask )
 				mPainter.drawTiledPixmap(  w - bdWidth, bdWidth,  bdWidth, h - bdWidth * 2, *srcMask );
 			else
 				mPainter.fillRect( w - bdWidth, bdWidth, bdWidth, h - bdWidth * 2, color1 );
 		}
 		p.end();
 		mPainter.end();
 		pixmap->setMask( mask );
 		cache->insert( pixmap, OThemeCache::FullScale, widget, true );
 		if ( !pixmap->mask() )
 			qDebug ( "No mask for border pixmap!\n" );
 	}
 	return ( pixmap );
 }
 
 
 OThemePixmap* OThemeBase::blend( WidgetType widget )
 {
 	OGfxEffect::GradientType g;
 	switch ( gradients[ widget ] ) {
 		case GrHorizontal:
 			g = OGfxEffect::HorizontalGradient;
 			break;
 		case GrVertical:
 			g = OGfxEffect::VerticalGradient;
 			break;
 		case GrPyramid:
 			g = OGfxEffect::PyramidGradient;
 			break;
 		case GrRectangle:
 			g = OGfxEffect::RectangleGradient;
 			break;
 		case GrElliptic:
 			g = OGfxEffect::EllipticGradient;
 			break;
 		default:
 			g = OGfxEffect::DiagonalGradient;
 			break;
 	}
 	OGfxEffect::blend( *pixmaps[ widget ], blends[ widget ], *grLowColors[ widget ],
 	                   g, false );
 	return ( pixmaps[ widget ] );
 }
 
 OThemePixmap* OThemeBase::gradient( int w, int h, WidgetType widget )
 {
 	if ( gradients[ widget ] == GrVertical ) {
 		if ( !pixmaps[ widget ] || pixmaps[ widget ] ->height() != h ) {
 			OThemePixmap * cachePix = cache->verticalPixmap( h, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::VerticalScale,
 					               widget );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::VerticalScale,
 					               widget );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->resize( w, h );
 				OGfxEffect::gradient( *pixmaps[ widget ], *grHighColors[ widget ],
 				                      *grLowColors[ widget ],
 				                      OGfxEffect::VerticalGradient );
 			}
 		}
 	}
 	else if ( gradients[ widget ] == GrHorizontal ) {
 		if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ) {
 			OThemePixmap * cachePix = cache->horizontalPixmap( w, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ],
 					               OThemeCache::HorizontalScale, widget );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ],
 					               OThemeCache::HorizontalScale, widget );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->resize( w, h );
 				OGfxEffect::gradient( *pixmaps[ widget ], *grHighColors[ widget ],
 				                      *grLowColors[ widget ],
 				                      OGfxEffect::HorizontalGradient );
 			}
 		}
 	}
 	else if ( gradients[ widget ] == GrReverseBevel ) {
 		if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
 		        pixmaps[ widget ] ->height() != h ) {
 			OThemePixmap * cachePix = cache->pixmap( w, h, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::FullScale,
 					               widget );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::FullScale,
 					               widget );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->resize( w, h );
 
 				QPixmap s;
 				int offset = decoWidth( widget );
 				s.resize( w - offset * 2, h - offset * 2 );
 				QColor lc( *grLowColors[ widget ] );
 				QColor hc( *grHighColors[ widget ] );
 				if ( bevelContrast( widget ) ) {
 					int bc = bevelContrast( widget );
 					// want single increments, not factors like light()/dark()
 					lc.setRgb( lc.red() - bc, lc.green() - bc, lc.blue() - bc );
 					hc.setRgb( hc.red() + bc, hc.green() + bc, hc.blue() + bc );
 				}
 				OGfxEffect::gradient( *pixmaps[ widget ],
 				                      lc, hc,
 				                      OGfxEffect::DiagonalGradient );
 				OGfxEffect::gradient( s, *grHighColors[ widget ],
 				                      *grLowColors[ widget ],
 				                      OGfxEffect::DiagonalGradient );
 				bitBlt( pixmaps[ widget ], offset, offset, &s, 0, 0, w - offset * 2,
 				        h - offset * 2, Qt::CopyROP );
 			}
 		}
 	}
 	else {
 		OGfxEffect::GradientType g;
 		switch ( gradients[ widget ] ) {
 			case GrPyramid:
 				g = OGfxEffect::PyramidGradient;
 				break;
 			case GrRectangle:
 				g = OGfxEffect::RectangleGradient;
 				break;
 			case GrElliptic:
 				g = OGfxEffect::EllipticGradient;
 				break;
 			default:
 				g = OGfxEffect::DiagonalGradient;
 				break;
 		}
 		if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
 		        pixmaps[ widget ] ->height() != h ) {
 			OThemePixmap * cachePix = cache->pixmap( w, h, widget );
 			if ( cachePix ) {
 				cachePix = new OThemePixmap( *cachePix );
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::FullScale,
 					               widget );
 				pixmaps[ widget ] = cachePix;
 			}
 			else {
 				if ( pixmaps[ widget ] )
 					cache->insert( pixmaps[ widget ], OThemeCache::FullScale,
 					               widget );
 				pixmaps[ widget ] = new OThemePixmap;
 				pixmaps[ widget ] ->resize( w, h );
 				OGfxEffect::gradient( *pixmaps[ widget ], *grHighColors[ widget ],
 				                      *grLowColors[ widget ], g );
 			}
 		}
 	}
 	return ( pixmaps[ widget ] );
 }
 
 OThemePixmap* OThemeBase::scalePixmap( int w, int h, WidgetType widget )
 {
 
 	if ( gradients[ widget ] && blends[ widget ] == 0.0 )
 		return ( gradient( w, h, widget ) );
 
 	return ( scale( w, h, widget ) );
 }
 
 QColorGroup* OThemeBase::makeColorGroup( QColor &fg, QColor &bg,
         Qt::GUIStyle )
 {
 	if ( shading == Motif ) {
 		int highlightVal, lowlightVal;
 		highlightVal = 100 + ( 2* /*KGlobalSettings::contrast()*/ 3 + 4 ) * 16 / 10;
 		lowlightVal = 100 + ( ( 2* /*KGlobalSettings::contrast()*/ 3 + 4 ) * 10 );
 		return ( new QColorGroup( fg, bg, bg.light( highlightVal ),
 		                          bg.dark( lowlightVal ), bg.dark( 120 ),