Fix config read

1 files changed, 6 insertions, 2 deletions

diff --git a/noncore/styles/theme/othemebase.cpp b/noncore/styles/theme/othemebase.cpp
index 00cea03..21d16f2 100644
--- a/noncore/styles/theme/othemebase.cpp
+++ b/noncore/styles/theme/othemebase.cpp
@@ -591,622 +591,626 @@ OThemePixmap* OThemeBase::scaleBorder( int w, int h, WidgetType widget )
 				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 ),
 		                          fg, qApp->palette().normal().base() ) );
 	}
 	else
 		return ( new QColorGroup( fg, bg, bg.light( 150 ), bg.dark(),
 		                          bg.dark( 120 ), fg,
 		                          qApp->palette().normal().base() ) );
 }
 
 static QColor strToColor ( const QString &str )
 {
 	QString str2 = str. stripWhiteSpace ( );
 	
 	if ( str2 [0] == '#' )
 		return QColor ( str2 );
 	else {
 		QStringList sl = QStringList::split ( ',', str2 );
 		
 		if ( sl. count ( ) >= 3 )
 			return QColor ( sl [0]. toInt ( ), sl [1]. toInt ( ), sl [2]. toInt ( ));
 	}
 	return QColor ( 0, 0, 0 );
 }
 
 
 
 void OThemeBase::applyMiscResourceGroup( Config *config )
 {
 	config-> setGroup ( "Misc" );
 	QString tmpStr;
 
 	tmpStr = config->readEntry( "SButtonPosition" );
 	if ( tmpStr == "BottomLeft" )
 		sbPlacement = SBBottomLeft;
 	else if ( tmpStr == "BottomRight" )
 		sbPlacement = SBBottomRight;
 	else {
 		if ( tmpStr != "Opposite" && !tmpStr.isEmpty() )
 			qDebug ( "OThemeBase: Unrecognized sb button option %s, using Opposite.\n", tmpStr.ascii() );
 		sbPlacement = SBOpposite;
 	}
 	tmpStr = config->readEntry( "ArrowType" );
 	if ( tmpStr == "Small" )
 		arrowStyle = SmallArrow;
 	else if ( tmpStr == "3D" )
 		arrowStyle = MotifArrow;
 	else {
 		if ( tmpStr != "Normal" && !tmpStr.isEmpty() )
 			qDebug ( "OThemeBase: Unrecognized arrow option %s, using Normal.\n", tmpStr.ascii() );
 		arrowStyle = LargeArrow;
 	}
 	tmpStr = config->readEntry( "ShadeStyle" );
 	if ( tmpStr == "Motif" )
 		shading = Motif;
 	else if ( tmpStr == "Next" )
 		shading = Next;
 	else if ( tmpStr == "KDE" )
 		shading = KDE;
 	else
 		shading = Windows;
 
 	defaultFrame = config->readNumEntry( "FrameWidth", 2 );
 	cacheSize = config->readNumEntry( "Cache", 1024 );
 	sbExtent = config->readNumEntry( "ScrollBarExtent", 16 );
 
 	config-> setGroup ( "General" );
 	
 	if ( config-> hasKey ( "foreground" ))        fgcolor    = strToColor ( config-> readEntry ( "foreground" ));
 	if ( config-> hasKey ( "background" ))        bgcolor    = strToColor ( config-> readEntry ( "background" ));
 	if ( config-> hasKey ( "selectForeground" ))  selfgcolor = strToColor ( config-> readEntry ( "selectForeground" ));
 	if ( config-> hasKey ( "selectBackground" ))  selbgcolor = strToColor ( config-> readEntry ( "selectBackground" ));
 	if ( config-> hasKey ( "windowForeground" ))  winfgcolor = strToColor ( config-> readEntry ( "windowForeground" ));
 	if ( config-> hasKey ( "windowBackground" ))  winbgcolor = strToColor ( config-> readEntry ( "windowBackground" ));
 }
 
 void OThemeBase::readMiscResourceGroup()
 {}
 
 void OThemeBase::applyResourceGroup( Config *config, int i, QString *copyfrom, QString *pixnames, QString *brdnames )
 {
 	QString tmpStr;
 
 	config-> setGroup ( widgetEntries [ i ] );
 
 	tmpStr = config->readEntry( "CopyWidget", "" );
 	copyfrom [ i ] = tmpStr;
 	if ( !tmpStr.isEmpty() )
 		return ;
 
 	// Scale hint
 	tmpStr = config->readEntry( "Scale" );
 	if ( tmpStr == "Full" )
 		scaleHints [ i ] = FullScale;
 	else if ( tmpStr == "Horizontal" )
 		scaleHints [ i ] = HorizontalScale;
 	else if ( tmpStr == "Vertical" )
 		scaleHints [ i ] = VerticalScale;
 	else {
 		if ( tmpStr != "Tile" && !tmpStr.isEmpty() )
 			qDebug ( "OThemeBase: Unrecognized scale option %s, using Tile.\n", tmpStr.ascii() );
 		scaleHints [ i ] = TileScale;
 	}
 
 
 	// Gradient type
 	tmpStr = config->readEntry( "Gradient" );
 	if ( tmpStr == "Diagonal" )
 		gradients [ i ] = GrDiagonal;
 	else if ( tmpStr == "Horizontal" )
 		gradients [ i ] = GrHorizontal;
 	else if ( tmpStr == "Vertical" )
 		gradients [ i ] = GrVertical;
 	else if ( tmpStr == "Pyramid" )
 		gradients [ i ] = GrPyramid;
 	else if ( tmpStr == "Rectangle" )
 		gradients [ i ] = GrRectangle;
 	else if ( tmpStr == "Elliptic" )
 		gradients [ i ] = GrElliptic;
 	else if ( tmpStr == "ReverseBevel" )
 		gradients [ i ] = GrReverseBevel;
 	else {
 		if ( tmpStr != "None" && !tmpStr.isEmpty() )
 			qDebug ( "OThemeBase: Unrecognized gradient option %s, using None.\n", tmpStr.ascii() );
 		gradients [ i ] = GrNone;
 	}
 
 	// Blend intensity
 	blends[ i ] = config->readEntry( "BlendIntensity", "0.0" ).toDouble();
 
 	// Bevel contrast
 	bContrasts[ i ] = config->readNumEntry( "BevelContrast", 0 );
 
 	// Border width
 	borders [ i ] = config->readNumEntry( "Border", 1 );
 
 	// Highlight width
 	highlights [ i ] = config->readNumEntry( "Highlight", 1 );
 
 	// Gradient low color or blend background
 	if ( config->hasKey( "GradientLow" ) && ( gradients[ i ] != GrNone || blends[ i ] != 0.0 ))
 		grLowColors[ i ] = new QColor( strToColor ( config->readEntry( "GradientLow", qApp->palette().normal().background().name() )));
 	else
 		grLowColors[ i ] = NULL;
 	
 
 	// Gradient high color
 	if ( config->hasKey( "GradientHigh" ) && ( gradients[ i ] != GrNone )) 
 		grHighColors[ i ] = new QColor( strToColor ( config->readEntry( "GradientHigh", qApp->palette().normal().background().name() )));
 	else
 		grHighColors[ i ] = NULL;
 
 	// Extended color attributes
 	if ( config->hasKey( "Foreground" ) || config->hasKey( "Background" ) ) {
 		QColor bg = strToColor( config->readEntry( "Background", qApp->palette().normal().background().name() ));
 		QColor fg = strToColor( config->readEntry( "Foreground", qApp->palette().normal().foreground().name() ));
 
 		colors[ i ] = makeColorGroup( fg, bg, Qt::WindowsStyle );
 	}
 	else
 		colors[ i ] = NULL;
 
 	// Pixmap
 	tmpStr = config->readEntry( "Pixmap", "" );
 	pixnames[ i ] = tmpStr;
 	duplicate[ i ] = false;
 	pixmaps[ i ] = NULL;
 	images[ i ] = NULL;
 
 
 	// Pixmap border
 	tmpStr = config->readEntry( "PixmapBorder", "" );
 	brdnames[ i ] = tmpStr;
 	pbDuplicate[ i ] = false;
 	pbPixmaps[ i ] = NULL;
 	pbWidth[ i ] = 0;
 	if ( !tmpStr.isEmpty() ) {
 		pbWidth[ i ] = config->readNumEntry( "PixmapBWidth", 0 );
 		if ( pbWidth[ i ] == 0 ) {
 			qDebug ( "OThemeBase: No border width specified for pixmapped border widget %s\n", widgetEntries[ i ] );
 			qDebug ( "OThemeBase: Using default of 2.\n" );
 			pbWidth[ i ] = 2;
 		}
 	}
 
 
 	// Various widget specific settings. This was more efficent when bunched
 	// together in the misc group, but this makes an easier to read config.
 	if ( i == SliderGroove )
 		roundedSlider = config->readBoolEntry( "SmallGroove", false );
-	else if ( i == ActiveTab || i == InactiveTab )
-		aTabLine = iTabLine = config->readBoolEntry( "BottomLine", true );
+	else if ( i == ActiveTab ) {
+		aTabLine = config->readBoolEntry( "BottomLine", true );
+	}
+	else if ( i == InactiveTab ) {
+		iTabLine = config->readBoolEntry( "BottomLine", true );
+	}
 	else if ( i == Splitter )
 		splitterWidth = config->readNumEntry( "Width", 10 );
 	else if ( i == ComboBox || i == ComboBoxDown ) {
 		roundedCombo = config->readBoolEntry( "Round", false );
 	}
 	else if ( i == PushButton || i == PushButtonDown ) {
 		btnXShift = config->readNumEntry( "XShift", 0 );
 		btnYShift = config->readNumEntry( "YShift", 0 );
 		focus3D = config->readBoolEntry( "3DFocusRect", false );
 		focus3DOffset = config->readBoolEntry( "3DFocusOffset", 0 );
 		roundedButton = config->readBoolEntry( "Round", false );
 	}
 }
 
 
 void OThemeBase::readResourceGroup( int i, QString *copyfrom, QString *pixnames, QString *brdnames,
                                     bool *loadArray )
 {
 	if ( loadArray[ i ] == true ) {
 		return ; // already been preloaded.
 	}
 
 	int tmpVal;
 	QString tmpStr;
 
 	tmpStr = copyfrom [ i ];
 	if ( !tmpStr.isEmpty() ) { // Duplicate another widget's config
 		int sIndex;
 		loadArray[ i ] = true;
 		for ( sIndex = 0; sIndex < WIDGETS; ++sIndex ) {
 			if ( tmpStr == widgetEntries[ sIndex ] ) {
 				if ( !loadArray[ sIndex ] )  // hasn't been loaded yet
 					readResourceGroup( sIndex, copyfrom, pixnames, brdnames,
 					                   loadArray );
 				break;
 			}
 		}
 		if ( loadArray[ sIndex ] ) {
 			copyWidgetConfig( sIndex, i, pixnames, brdnames );
 		}
 		else
 			qDebug ( "OThemeBase: Unable to identify source widget for %s\n", widgetEntries[ i ] );
 		return ;
 	}
 	// special inheritance for disabled arrows (these are tri-state unlike
 	// the rest of what we handle).
 	for ( tmpVal = DisArrowUp; tmpVal <= DisArrowRight; ++tmpVal ) {
 		if ( tmpVal == i ) {
 			tmpStr = pixnames [ i ];
 			if ( tmpStr.isEmpty() ) {
 				copyWidgetConfig( ArrowUp + ( tmpVal - DisArrowUp ), i, pixnames,
 				                  brdnames );
 				return ;
 			}
 		}
 	}
 
 	// Pixmap
 	int existing;
 	// Scan for duplicate pixmaps(two identical pixmaps, tile scale, no blend,
 	// no pixmapped border)
 	if ( !pixnames [ i ].isEmpty() ) {
 		for ( existing = 0; existing < i; ++existing ) {
 			if ( pixnames[ i ] == pixnames[ existing ] && scaleHints[ i ] == TileScale &&
 			        scaleHints[ existing ] == TileScale && blends[ existing ] == 0.0 &&
 			        blends[ i ] == 0.0 ) {
 				pixmaps[ i ] = pixmaps[ existing ];
 				duplicate[ i ] = true;
 				break;
 			}
 		}
 	}
 	// load
 	if ( !duplicate[ i ] && !pixnames[ i ].isEmpty() ) {
 		pixmaps[ i ] = loadPixmap( pixnames[ i ] );
 		// load and save images for scaled/blended widgets for speed.
 		if ( scaleHints[ i ] == TileScale && blends[ i ] == 0.0 )
 			images[ i ] = NULL;
 		else
 			images[ i ] = loadImage( pixnames[ i ] );
 	}
 
 	// Pixmap border
 	if ( !brdnames [ i ]. isEmpty () ) {
 		// duplicate check
 		for ( existing = 0; existing < i; ++existing ) {
 			if ( brdnames [i] == brdnames[ existing ] ) {
 				pbPixmaps[ i ] = pbPixmaps[ existing ];
 				pbDuplicate[ i ] = true;
 				break;
 			}
 		}
 	}
 	// load
 	if ( !pbDuplicate[ i ] && !brdnames[ i ].isEmpty() )
 		pbPixmaps[ i ] = loadPixmap( brdnames[ i ] );
 
 	if ( pbPixmaps[ i ] && !pbDuplicate[ i ] )
 		generateBorderPix( i );
 
 	loadArray[ i ] = true;
 }
 
 
 OThemePixmap::OThemePixmap( bool timer )
 		: QPixmap()
 {
 	if(timer){
 	   t = new QTime;
 	    t->start();
 	}
 	else
 	    t = NULL;
 	int i;
 	for ( i = 0; i < 8; ++i )
 		b[ i ] = NULL;
 }
 
 OThemePixmap::OThemePixmap( const OThemePixmap &p )
 		: QPixmap( p )
 {
 	if(p.t){
 	    t = new QTime;
 	    t->start();
 	}
 	else
 	    t = NULL;
 	int i;
 	for ( i = 0; i < 8; ++i )
 		if ( p.b[ i ] )
 			b[ i ] = new QPixmap( *p.b[ i ] );
 		else
 			b[ i ] = NULL;
 }
 
 
 
 OThemePixmap::~OThemePixmap()
 {
 	if(t)
 	    delete t;
 	int i;
 	for ( i = 0; i < 8; ++i )
 		if ( b[ i ] )
 			delete b[ i ];
 }
 
 OThemeCache::OThemeCache( int maxSize, QObject *parent, const char *name )
 		: QObject( parent, name )
 {
 	cache.setMaxCost( maxSize * 1024 );
 	cache.setAutoDelete( true );
 	flushTimer.start(300000); // 5 minutes
 	connect(&flushTimer, SIGNAL(timeout()), SLOT(flushTimeout()));
 }
 
 void OThemeCache::flushTimeout()
 {
 	QIntCacheIterator<OThemePixmap> it( cache );
 	while ( it.current() ) {
 		if ( it.current() ->isOld() )
 			cache.remove( it.currentKey() );
 		else
 			++it;
 	}
 }
 
 OThemePixmap* OThemeCache::pixmap( int w, int h, int widgetID, bool border,
                                    bool mask )
 {
 
 	kthemeKey key;
 	key.cacheKey = 0; // shut up, gcc
 	key.data.id = widgetID;
 	key.data.width = w;
 	key.data.height = h;
 	key.data.border = border;
 	key.data.mask = mask;
 
 	OThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
 	if ( pix )
 		pix->updateAccessed();
 	return ( pix );
 }
 
 OThemePixmap* OThemeCache::horizontalPixmap( int w, int widgetID )
 {
 	kthemeKey key;
 	key.cacheKey = 0; // shut up, gcc
 	key.data.id = widgetID;
 	key.data.width = w;
 	key.data.height = 0;
 	key.data.border = false;
 	key.data.mask = false;
 	OThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
 	if ( pix )
 		pix->updateAccessed();
 	return ( pix );
 }
 
 OThemePixmap* OThemeCache::verticalPixmap( int h, int widgetID )
 {
 	kthemeKey key;
 	key.cacheKey = 0; // shut up, gcc
 	key.data.id = widgetID;
 	key.data.width = 0;
 	key.data.height = h;
 	key.data.border = false;
 	key.data.mask = false;
 	OThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
 	if ( pix )
 		pix->updateAccessed();
 	return ( pix );
 }
 
 bool OThemeCache::insert( OThemePixmap *pixmap, ScaleHint scale, int widgetID,
                           bool border, bool mask )
 {
 	kthemeKey key;
 	key.cacheKey = 0; // shut up, gcc
 	key.data.id = widgetID;
 	key.data.width = ( scale == FullScale || scale == HorizontalScale ) ?
 	                 pixmap->width() : 0;
 	key.data.height = ( scale == FullScale || scale == VerticalScale ) ?
 	                  pixmap->height() : 0;
 	key.data.border = border;
 	key.data.mask = mask;
 
 	if ( cache.find( ( unsigned long ) key.cacheKey, true ) != NULL ) {
 		return ( true ); // a pixmap of this scale is already in there
 	}
 	return ( cache.insert( ( unsigned long ) key.cacheKey, pixmap,
 	                       pixmap->width() * pixmap->height() * pixmap->depth() / 8 ) );
 }
 
 //#include "kthemebase.moc"