Rename KStyle to TDEStyle to avoid conflicts with KDE4.

1 files changed, 1828 insertions, 0 deletions

diff --git a/tdestyles/kthemestyle/kthemebase.cpp b/tdestyles/kthemestyle/kthemebase.cpp
new file mode 100644
index 000000000..8e1f5605f
--- /dev/null
+++ b/tdestyles/kthemestyle/kthemebase.cpp
@@ -0,0 +1,1828 @@
+/*
+ $Id$
+
+ This file is part of the KDE libraries
+ Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>
+
+ KDE3 port (C) 2001-2002 Maksim Orlovich <mo002j@mail.rochester.edu>
+ Port version 0.9.7
+
+ Palette setup code is from TDEApplication,
+		Copyright (C) 1997 Matthias Kalle Dalheimer (kalle@kde.org)
+		Copyright (C) 1998, 1999, 2000 KDE Team
+
+  Includes code portions from the KDE HighColor style.
+
+		KDE3 HighColor Style
+		Copyright (C) 2001 Karol Szwed       <gallium@kde.org>
+		(C) 2001 Fredrik H�glund   <fredrik@kde.org>
+
+		Drawing routines adapted from the KDE2 HCStyle,
+		Copyright (C) 2000 Daniel M. Duley   <mosfet@kde.org>
+		(C) 2000 Dirk Mueller      <mueller@kde.org>
+		(C) 2001 Martijn Klingens  <klingens@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., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kthemebase.h"
+#include <kpixmapeffect.h>
+#include <tqimage.h>
+#include <tqpainter.h>
+#include <tqbitmap.h>
+#include <stdlib.h>
+
+#include <tqsettings.h>
+#include <tqapplication.h>
+#include <tqscrollbar.h>
+
+typedef TQMap<TQString, TQString> Prop;
+
+template class TQIntCache<KThemePixmap>
+;
+
+/*
+Bugs:
+Can't delete old slider image when calculating the rotated one for some reason.
+*/
+
+//Shamelessly stolen from TDEConfigBase
+static TQColor readColorEntry( TQSettings* s, const char *pKey,
+                              const TQColor* pDefault )
+{
+    TQColor aRetColor;
+    int nRed = 0, nGreen = 0, nBlue = 0;
+
+    TQString aValue = s->readEntry( pKey );
+    if ( !aValue.isEmpty() )
+    {
+        if ( aValue.at( 0 ) == '#' )
+        {
+            aRetColor.setNamedColor( aValue );
+        }
+        else
+        {
+            bool bOK;
+            // find first part (red)
+            int nIndex = aValue.find( ',' );
+            if ( nIndex == -1 )
+            {
+                // return a sensible default -- Bernd
+                if ( pDefault )
+                    aRetColor = *pDefault;
+                return aRetColor;
+            }
+
+            nRed = aValue.left( nIndex ).toInt( &bOK );
+
+            // find second part (green)
+            int nOldIndex = nIndex;
+            nIndex = aValue.find( ',', nOldIndex + 1 );
+
+            if ( nIndex == -1 )
+            {
+                // return a sensible default -- Bernd
+                if ( pDefault )
+                    aRetColor = *pDefault;
+                return aRetColor;
+            }
+            nGreen = aValue.mid( nOldIndex + 1,
+                                 nIndex - nOldIndex - 1 ).toInt( &bOK );
+
+            // find third part (blue)
+            nBlue = aValue.right( aValue.length() - nIndex - 1 ).toInt( &bOK );
+
+            aRetColor.setRgb( nRed, nGreen, nBlue );
+        }
+    }
+    else
+    {
+
+        if ( pDefault )
+            aRetColor = *pDefault;
+    }
+
+    return aRetColor;
+}
+
+
+static const char * const 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", "CheckBoxTri", "RadioDown", "Radio", "HBarHandle", "VBarHandle",
+        "ToolBar", "Splitter", "CheckMark", "MenuBar", "DisableArrowUp",
+        "DisableArrowDown", "DisableArrowLeft", "DisableArrowRight", "ProgressBar",
+        "ProgressBackground", "MenuBarItem", "Background", "RotSlider", 
+        "RotInactiveTab", "RotActiveTab",
+    };
+
+#define INHERIT_ITEMS 16
+
+
+class KThemeBasePrivate
+{
+public:
+    /** Color overrides flags..*/
+    bool overrideForeground;
+    bool overrideBackground;
+    bool overrideSelectForeground;
+    bool overrideSelectBackground;
+    bool overrideWindowForeground;
+    bool overrideWindowBackground;
+
+    /**
+    * Colors to override defaults with..
+    */
+    TQColor overrideForegroundCol;
+    TQColor overrideBackgroundCol;
+    TQColor overrideSelectForegroundCol;
+    TQColor overrideSelectBackgroundCol;
+    TQColor overrideWindowForegroundCol;
+    TQColor overrideWindowBackgroundCol;
+
+    int contrast;
+
+
+    TQMap <TQString, TQMap<TQString, TQString> > props;
+
+    TQMap<const TQPixmap*, TQColor> colorCache;
+
+    /*
+    A heuristic routine that tries to determine the  avergae color of the image
+    Wouldn't work for things like sliders, etc.
+    */
+    TQColor pixmapAveColor( const TQPixmap* p )
+    {
+        if ( colorCache.contains( p ) )
+            return colorCache[ p ];
+
+        TQImage to_ave = p->convertToImage();
+        double h = 0, s = 0, v = 0;
+        int count = 0;
+        int dh, ds, dv;
+        for ( int x = 0; x < p->width(); x++ )
+        {
+            TQColor pix( to_ave.pixel( x, p->height() / 2 ) );
+            pix.hsv( &dh, &ds, &dv );
+            h += dh;
+            s += ds;
+            v += dv;
+            count++;
+        }
+
+        for ( int y = 0; y < p->height(); y++ )
+        {
+            TQColor pix( to_ave.pixel( p->width() / 2, y ) );
+            pix.hsv( &dh, &ds, &dv );
+            h += dh;
+            s += ds;
+            v += dv;
+            count++;
+        }
+        colorCache[ p ] = TQColor( int( h / count + 0.5 ), int( s / count + 0.5 ), int( v / count + 0.5 ), TQColor::Hsv );
+        return colorCache[ p ];
+    }
+};
+
+
+
+// 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;
+};
+
+#define KDE_TQBITMAP_TO_TQPAINTDEVICE(x) TQT_TQPAINTDEVICE_CONST(static_cast<const TQPixmap*>(static_cast<const TQBitmap*>(x)))
+
+void KThemeBase::generateBorderPix( int i )
+{
+    // separate pixmap into separate components
+    if ( pbPixmaps[ i ] )
+    {
+        // evidently I have to do masks manually...
+        const TQBitmap * srcMask = pbPixmaps[ i ] ->mask();
+        TQBitmap destMask( pbWidth[ i ], pbWidth[ i ] );
+        TQPixmap tmp( pbWidth[ i ], pbWidth[ i ] );
+
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), 0, 0, pbWidth[ i ], pbWidth[ i ],
+                TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0, pbWidth[ i ], pbWidth[ i ],
+                    TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::TopLeft, tmp );
+
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), pbPixmaps[ i ] ->width() - pbWidth[ i ], 0,
+                pbWidth[ i ], pbWidth[ i ], TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), pbPixmaps[ i ] ->width() - pbWidth[ i ],
+                    0, pbWidth[ i ], pbWidth[ i ], TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::TopRight, tmp );
+
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), 0, pbPixmaps[ i ] ->height() - pbWidth[ i ],
+                pbWidth[ i ], pbWidth[ i ], TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, pbPixmaps[ i ] ->height() - pbWidth[ i ],
+                    pbWidth[ i ], pbWidth[ i ], TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::BottomLeft, tmp );
+
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), pbPixmaps[ i ] ->width() - pbWidth[ i ],
+                pbPixmaps[ i ] ->height() - pbWidth[ i ], pbWidth[ i ], pbWidth[ i ],
+                TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), pbPixmaps[ i ] ->width() - pbWidth[ i ],
+                    pbPixmaps[ i ] ->height() - pbWidth[ i ], pbWidth[ i ], pbWidth[ i ],
+                    TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::BottomRight, tmp );
+
+        tmp.resize( pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ] );
+        destMask.resize( pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ] );
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), pbWidth[ i ], 0,
+                pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), pbWidth[ i ], 0,
+                    pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ],
+                    TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::Top, tmp );
+
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), pbWidth[ i ],
+                pbPixmaps[ i ] ->height() - pbWidth[ i ],
+                pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), pbWidth[ i ],
+                    pbPixmaps[ i ] ->height() - pbWidth[ i ],
+                    pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::Bottom, tmp );
+
+        tmp.resize( pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2 );
+        destMask.resize( pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2 );
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), 0, pbWidth[ i ], pbWidth[ i ],
+                pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2, TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, pbWidth[ i ], pbWidth[ i ],
+                    pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2, TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::Left, tmp );
+
+        bitBlt( TQT_TQPAINTDEVICE(&tmp), 0, 0, TQT_TQPAINTDEVICE(pbPixmaps[ i ]), pbPixmaps[ i ] ->width() - pbWidth[ i ],
+                pbWidth[ i ], pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2,
+                TQt::CopyROP, false );
+        if ( srcMask )
+        {
+            bitBlt( TQT_TQPAINTDEVICE(&destMask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), pbPixmaps[ i ] ->width() - pbWidth[ i ],
+                    pbWidth[ i ], pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2,
+                    TQt::CopyROP, false );
+            tmp.setMask( destMask );
+        }
+        pbPixmaps[ i ] ->setBorder( KThemePixmap::Right, tmp );
+    }
+    else
+        tqWarning( "KThemeBase: Tried making border from empty pixmap\n" );
+}
+
+
+void KThemeBase::copyWidgetConfig( int sourceID, int destID, TQString *pixnames,
+                                   TQString *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 TQColor( *grLowColors[ sourceID ] );
+    else
+        grLowColors[ destID ] = NULL;
+
+    if ( grHighColors[ sourceID ] )
+        grHighColors[ destID ] = new TQColor( *grHighColors[ sourceID ] );
+    else
+        grHighColors[ destID ] = NULL;
+
+    if ( colors[ sourceID ] )
+        colors[ destID ] = new TQColorGroup( *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 KThemeBase::readConfig( TQt::GUIStyle /*style*/ )
+{
+#define PREBLEND_ITEMS 12
+    static const WidgetType preBlend[] =
+        {
+            Slider, IndicatorOn, IndicatorOff,
+            ExIndicatorOn, ExIndicatorOff, HScrollDeco, VScrollDeco, HScrollDecoDown,
+            VScrollDecoDown, ComboDeco, ComboDecoDown, CheckMark
+        };
+
+    int i;
+    TQString tmpStr;
+    TQString pixnames[ WIDGETS ]; // used for duplicate check
+    TQString brdnames[ WIDGETS ];
+    bool loaded[ WIDGETS ]; // used for preloading for CopyWidget
+
+    TQSettings config;
+    if (configDirName.isEmpty() || configDirName == ".")
+    {
+    	TDEStyleDirs::dirs()->addToSearch( "themerc", config );
+    }
+    else config.insertSearchPath( TQSettings::Unix, configDirName );
+
+    applyConfigFile( config );
+
+    d->contrast = config.readNumEntry( configFileName + "KDE/contrast", 7 );
+
+
+
+    for ( i = 0; i < INHERIT_ITEMS; ++i )
+        applyResourceGroup( &config, i );
+    for ( ; i < INHERIT_ITEMS*2; ++i )
+    {
+        if ( config.entryList( configFileName + widgetEntries[ i ] ).size() )
+            applyResourceGroup( &config, i );
+#ifndef Q_WS_QWS //FIXME
+
+        else
+        {
+            Prop& copyProp = d->props[ widgetEntries[ i ] ];
+            copyProp[ "CopyWidget" ] = TQString( widgetEntries[ i - INHERIT_ITEMS ] );
+        }
+#endif
+
+    }
+    for ( ; i < WIDGETS; ++i )
+        applyResourceGroup( &config, i );
+    applyMiscResourceGroup( &config );
+
+    // initialize 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;
+
+    //Handle the rotated background separately..
+    d->props[ widgetEntries[ RotSliderGroove ] ] = d->props[ widgetEntries[ SliderGroove ] ];
+    d->props[ widgetEntries[ RotInactiveTab ] ]  = d->props[ widgetEntries[ InactiveTab ] ];
+    d->props[ widgetEntries[ RotActiveTab ] ]    = d->props[ widgetEntries[ ActiveTab ] ];
+
+    // misc items
+    readMiscResourceGroup();
+
+
+    for ( i = 0; i < WIDGETS; ++i )
+        readResourceGroup( i, pixnames, brdnames, loaded );
+
+    if ( pixmaps[ RotSliderGroove ] )
+    {
+        TQWMatrix r270; //TODO: 90 if reverse?
+        r270.rotate( 270 );
+        KThemePixmap* bf = new KThemePixmap( pixmaps[ RotSliderGroove ], pixmaps[ RotSliderGroove ] ->xForm( r270 ) ); //
+        pixmaps[ RotSliderGroove ] = bf;
+        if ( images[ RotSliderGroove ] )
+        {
+            delete images[ RotSliderGroove ];
+            images[ RotSliderGroove ] = new TQImage( bf->convertToImage() );
+        }
+    }
+
+    if ( pixmaps[ RotActiveTab ] )
+    {
+        TQWMatrix r180; 
+        r180.rotate( 180 );
+        KThemePixmap* bf = new KThemePixmap( pixmaps[ RotActiveTab ], pixmaps[ RotActiveTab ] ->xForm( r180 ) );
+        
+        pixmaps[ RotActiveTab ] = bf;
+        if ( images[ RotActiveTab ] )
+        {
+            delete images[ RotActiveTab ];
+            images[ RotActiveTab ] = new TQImage( bf->convertToImage() );
+        }
+    }
+    
+    if ( pixmaps[ RotInactiveTab ] )
+    {
+        TQWMatrix r180; 
+        r180.rotate( 180 );
+        KThemePixmap* bf = new KThemePixmap( pixmaps[ RotInactiveTab ], pixmaps[ RotInactiveTab ] ->xForm( r180 ) );
+        
+        pixmaps[ RotInactiveTab ] = bf;
+        if ( images[ RotInactiveTab ] )
+        {
+            delete images[ RotInactiveTab ];
+            images[ RotInactiveTab ] = new TQImage( bf->convertToImage() );
+        }
+    }
+
+    // Handle preblend items
+    for ( i = 0; i < PREBLEND_ITEMS; ++i )
+    {
+        if ( pixmaps[ preBlend[ i ] ] != NULL && blends[ preBlend[ i ] ] != 0.0 )
+            blend( preBlend[ i ] );
+    }
+
+    d->props.clear();
+}
+
+KThemeBase::KThemeBase( const TQString& dir, const TQString & configFile )
+        : TDEStyle( FilledFrameWorkaround ), configFileName( configFile )
+{
+    d = new KThemeBasePrivate;
+    if ( configFileName.isEmpty() )
+        configFileName = "tdestylerc";
+
+
+    configDirName = dir;
+    //Strip of rc from the configFileName
+    if ( configFileName.endsWith( "rc" ) )
+    {
+        configFileName.truncate( configFileName.length() - 2 ); //Get rid of rc..
+    }
+    //else SCREAM!!
+
+
+    configFileName = "/" + configFileName + "/";
+
+    readConfig( TQt::WindowsStyle );
+    cache = new KThemeCache( cacheSize );
+
+    switch ( scrollBarLayout() )
+    {
+        case SBBottomLeft:
+            setScrollBarType( NextStyleScrollBar );
+            break;
+        case SBBottomRight:
+            setScrollBarType( PlatinumStyleScrollBar );
+            break;
+        case SBOpposite:
+            break;
+            //Do nothing, this type already set..
+    }
+    ;
+}
+
+void KThemeBase::applyConfigFile( TQSettings& config )
+{
+    TQStringList keys = config.entryList( configFileName );
+
+    if ( keys.contains( "foreground" ) )
+    {
+        d->overrideForeground = true;
+        d->overrideForegroundCol = readColorEntry( &config, ( configFileName + "foreground" ).latin1(), 0 );
+    }
+    else
+        d->overrideForeground = false;
+
+    if ( keys.contains( "background" ) )
+    {
+        d->overrideBackground = true;
+        d->overrideBackgroundCol = readColorEntry( &config, ( configFileName + "background" ).latin1(), 0 );
+    }
+    else
+        d->overrideBackground = false;
+
+
+
+    if ( keys.contains( "selectForeground" ) )
+    {
+        d->overrideSelectForeground = true;
+        d->overrideSelectForegroundCol = readColorEntry( &config, ( configFileName + "selectForeground" ).latin1(), 0 );
+    }
+    else
+        d->overrideSelectForeground = false;
+
+    if ( keys.contains( "selectBackground" ) )
+    {
+        d->overrideSelectBackground = true;
+        d->overrideSelectBackgroundCol = readColorEntry( &config, ( configFileName + "selectBackground" ).latin1(), 0 );
+    }
+    else
+        d->overrideSelectBackground = false;
+
+    if ( keys.contains( "windowBackground" ) )
+    {
+        d->overrideWindowBackground = true;
+        d->overrideWindowBackgroundCol = readColorEntry( &config, ( configFileName + "windowBackground" ).latin1(), 0 );
+    }
+    else
+        d->overrideWindowBackground = false;
+
+
+    if ( keys.contains( "windowForeground" ) )
+    {
+        d->overrideWindowForeground = true;
+        d->overrideWindowForegroundCol = readColorEntry( &config, ( configFileName + "windowForeground" ).latin1(), 0 );
+    }
+    else
+        d->overrideWindowForeground = false;
+
+
+#ifndef Q_WS_QWS //FIXME
+
+    for ( int input = 0; input < WIDGETS; ++input )
+    {
+        d->props.erase( widgetEntries[ input ] );
+    }
+    d->props.erase( "Misc" );
+#endif
+}
+
+KThemeBase::~KThemeBase()
+{
+    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 ] );
+    }
+    TDEStyleDirs::release();
+    delete cache;
+    delete d;
+}
+
+TQImage* KThemeBase::loadImage( const TQString &name )
+{
+    TQImage * image = new TQImage;
+    TQString path = TDEStyleDirs::dirs()->findResource( "themepixmap",name );
+    image->load( path );
+    if ( !image->isNull() )
+        return ( image );
+    tqWarning( "KThemeBase: Unable to load image %s\n", name.latin1() );
+    delete image;
+    return ( NULL );
+}
+
+KThemePixmap* KThemeBase::loadPixmap( const TQString &name )
+{
+    KThemePixmap * pixmap = new KThemePixmap( false );
+    TQString path = TDEStyleDirs::dirs()->findResource( "themepixmap", name );
+    pixmap->load( path );
+    if ( !pixmap->isNull() )
+        return pixmap;
+    tqWarning( "KThemeBase: Unable to load pixmap %s\n", name.latin1() );
+    delete pixmap;
+    return ( NULL );
+}
+
+
+KThemePixmap* KThemeBase::scale( int w, int h, WidgetType widget ) const
+{
+    if ( scaleHints[ widget ] == FullScale )
+    {
+        if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
+                pixmaps[ widget ] ->height() != h )
+        {
+            KThemePixmap * cachePix = cache->pixmap( w, h, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::FullScale,
+                                   widget );
+                else
+                    tqWarning( "We would have inserted a null pixmap!\n" );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                cache->insert( pixmaps[ widget ], KThemeCache::FullScale, widget );
+                TQImage tmpImg = images[ widget ] ->smoothScale( w, h );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->convertFromImage( tmpImg );
+                if ( blends[ widget ] != 0.0 )
+                    blend( widget );
+            }
+        }
+    }
+    else if ( scaleHints[ widget ] == HorizontalScale )
+    {
+        if ( pixmaps[ widget ] ->width() != w )
+        {
+            KThemePixmap * cachePix = cache->horizontalPixmap( w, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::HorizontalScale, widget );
+                else
+                    tqWarning( "We would have inserted a null pixmap!\n" );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                cache->insert( pixmaps[ widget ], KThemeCache::HorizontalScale, widget );
+                TQImage tmpImg = images[ widget ] ->
+                                smoothScale( w, images[ widget ] ->height() );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->convertFromImage( tmpImg );
+                if ( blends[ widget ] != 0.0 )
+                    blend( widget );
+            }
+        }
+    }
+    else if ( scaleHints[ widget ] == VerticalScale )
+    {
+        if ( pixmaps[ widget ] ->height() != h )
+        {
+            KThemePixmap * cachePix = cache->verticalPixmap( w, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::VerticalScale, widget );
+                else
+                    tqWarning( "We would have inserted a null pixmap!\n" );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                cache->insert( pixmaps[ widget ], KThemeCache::VerticalScale, widget );
+                TQImage tmpImg =
+                    images[ widget ] ->smoothScale( images[ widget ] ->width(), h );
+                pixmaps[ widget ] = new KThemePixmap;
+                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 )
+        {
+            KThemePixmap * cachePix = cache->pixmap( w, h, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                cache->insert( pixmaps[ widget ], KThemeCache::FullScale, widget );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                cache->insert( pixmaps[ widget ], KThemeCache::FullScale, widget );
+                TQPixmap tile;
+                tile.convertFromImage( *images[ widget ] );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->resize( w, h );
+                TQPainter p( pixmaps[ widget ] );
+                p.drawTiledPixmap( 0, 0, w, h, tile );
+                if ( blends[ widget ] != 0.0 )
+                    blend( widget );
+            }
+        }
+    }
+    return ( pixmaps[ widget ] );
+}
+
+KThemePixmap* KThemeBase::scaleBorder( int w, int h, WidgetType widget ) const
+{
+    KThemePixmap * pixmap = NULL;
+    if ( !pbPixmaps[ widget ] && !pbWidth[ widget ] )
+        return ( NULL );
+    pixmap = cache->pixmap( w, h, widget, true );
+    if ( pixmap )
+    {
+        pixmap = new KThemePixmap( *pixmap );
+    }
+    else
+    {
+        pixmap = new KThemePixmap();
+        pixmap->resize( w, h );
+        TQBitmap mask;
+        mask.resize( w, h );
+        mask.fill( color0 );
+        TQPainter mPainter;
+        mPainter.begin( &mask );
+
+        TQPixmap *tmp = borderPixmap( widget ) ->border( KThemePixmap::TopLeft );
+        const TQBitmap *srcMask = tmp->mask();
+        int bdWidth = tmp->width();
+
+        bitBlt( TQT_TQPAINTDEVICE(pixmap), 0, 0, TQT_TQPAINTDEVICE(tmp), 0, 0, bdWidth, bdWidth,
+                TQt::CopyROP, false );
+        if ( srcMask )
+            bitBlt( TQT_TQPAINTDEVICE(&mask), 0, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0, bdWidth, bdWidth,
+                    TQt::CopyROP, false );
+        else
+            mPainter.fillRect( 0, 0, bdWidth, bdWidth, color1 );
+
+
+        tmp = borderPixmap( widget ) ->border( KThemePixmap::TopRight );
+        srcMask = tmp->mask();
+        bitBlt( TQT_TQPAINTDEVICE(pixmap), w - bdWidth, 0, TQT_TQPAINTDEVICE(tmp), 0, 0, bdWidth,
+                bdWidth, TQt::CopyROP, false );
+        if ( srcMask )
+            bitBlt( TQT_TQPAINTDEVICE(&mask), w - bdWidth, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0, bdWidth,
+                    bdWidth, TQt::CopyROP, false );
+        else
+            mPainter.fillRect( w - bdWidth, 0, bdWidth, bdWidth, color1 );
+
+        tmp = borderPixmap( widget ) ->border( KThemePixmap::BottomLeft );
+        srcMask = tmp->mask();
+        bitBlt( TQT_TQPAINTDEVICE(pixmap), 0, h - bdWidth, TQT_TQPAINTDEVICE(tmp), 0, 0, bdWidth,
+                bdWidth, TQt::CopyROP, false );
+        if ( srcMask )
+            bitBlt( TQT_TQPAINTDEVICE(&mask), 0, h - bdWidth, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0, bdWidth,
+                    bdWidth, TQt::CopyROP, false );
+        else
+            mPainter.fillRect( 0, h - bdWidth, bdWidth, bdWidth, color1 );
+
+        tmp = borderPixmap( widget ) ->border( KThemePixmap::BottomRight );
+        srcMask = tmp->mask();
+        bitBlt( TQT_TQPAINTDEVICE(pixmap), w - bdWidth, h - bdWidth, TQT_TQPAINTDEVICE(tmp), 0, 0,
+                bdWidth, bdWidth, TQt::CopyROP, false );
+        if ( srcMask )
+            bitBlt( TQT_TQPAINTDEVICE(&mask), w - bdWidth, h - bdWidth, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0,
+                    bdWidth, bdWidth, TQt::CopyROP, false );
+        else
+            mPainter.fillRect( w - bdWidth, h - bdWidth, bdWidth, bdWidth, color1 );
+
+        TQPainter p;
+        p.begin( pixmap );
+        if ( w - bdWidth * 2 > 0 )
+        {
+            tmp = borderPixmap( widget ) ->border( KThemePixmap::Top );
+            srcMask = tmp->mask();
+            p.drawTiledPixmap( bdWidth, 0, w - bdWidth * 2, bdWidth, *tmp );
+            if ( srcMask )
+                bitBlt( TQT_TQPAINTDEVICE(&mask), bdWidth, 0, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0,
+                        w - bdWidth * 2, bdWidth, TQt::CopyROP, false );
+            else
+                mPainter.fillRect( bdWidth, 0, w - bdWidth * 2, bdWidth, color1 );
+
+            tmp = borderPixmap( widget ) ->border( KThemePixmap::Bottom );
+            srcMask = tmp->mask();
+            p.drawTiledPixmap( bdWidth, h - bdWidth, w - bdWidth * 2, bdWidth,
+                               *tmp );
+            if ( srcMask )
+                bitBlt( TQT_TQPAINTDEVICE(&mask), bdWidth, h - bdWidth, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0,
+                        w - bdWidth * 2, bdWidth, TQt::CopyROP, false );
+            else
+                mPainter.fillRect( bdWidth, h - bdWidth, w - bdWidth * 2, bdWidth,
+                                   color1 );
+        }
+        if ( h - bdWidth * 2 > 0 )
+        {
+            tmp = borderPixmap( widget ) ->border( KThemePixmap::Left );
+            srcMask = tmp->mask();
+            p.drawTiledPixmap( 0, bdWidth, bdWidth, h - bdWidth * 2, *tmp );
+            if ( srcMask )
+                bitBlt( TQT_TQPAINTDEVICE(&mask), 0, bdWidth, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0,
+                        bdWidth, h - bdWidth * 2, TQt::CopyROP, false );
+            else
+                mPainter.fillRect( 0, bdWidth, bdWidth, h - bdWidth * 2, color1 );
+
+            tmp = borderPixmap( widget ) ->border( KThemePixmap::Right );
+            srcMask = tmp->mask();
+            p.drawTiledPixmap( w - bdWidth, bdWidth, bdWidth, h - bdWidth * 2,
+                               *tmp );
+            if ( srcMask )
+                bitBlt( TQT_TQPAINTDEVICE(&mask), w - bdWidth, bdWidth, KDE_TQBITMAP_TO_TQPAINTDEVICE(srcMask), 0, 0,
+                        bdWidth, h - bdWidth * 2, TQt::CopyROP, false );
+            else
+                mPainter.fillRect( w - bdWidth, bdWidth, bdWidth, h - bdWidth * 2, color1 );
+        }
+        p.end();
+        mPainter.end();
+        pixmap->setMask( mask );
+        cache->insert( pixmap, KThemeCache::FullScale, widget, true );
+        if ( !pixmap->mask() )
+            tqWarning( "No mask for border pixmap!\n" );
+    }
+    return ( pixmap );
+}
+
+
+KThemePixmap* KThemeBase::blend( WidgetType widget ) const
+{
+    KPixmapEffect::GradientType g;
+    switch ( gradients[ widget ] )
+    {
+        case GrHorizontal:
+            g = KPixmapEffect::HorizontalGradient;
+            break;
+        case GrVertical:
+            g = KPixmapEffect::VerticalGradient;
+            break;
+        case GrPyramid:
+            g = KPixmapEffect::PyramidGradient;
+            break;
+        case GrRectangle:
+            g = KPixmapEffect::RectangleGradient;
+            break;
+        case GrElliptic:
+            g = KPixmapEffect::EllipticGradient;
+            break;
+        default:
+            g = KPixmapEffect::DiagonalGradient;
+            break;
+    }
+    KPixmapEffect::blend( *pixmaps[ widget ], blends[ widget ], *grLowColors[ widget ],
+                          g, false );
+    return ( pixmaps[ widget ] );
+}
+
+KThemePixmap* KThemeBase::gradient( int w, int h, WidgetType widget ) const
+{
+    if ( gradients[ widget ] == GrVertical )
+    {
+        if ( !pixmaps[ widget ] || pixmaps[ widget ] ->height() != h )
+        {
+            KThemePixmap * cachePix = cache->verticalPixmap( h, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::VerticalScale,
+                                   widget );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::VerticalScale,
+                                   widget );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->resize( w, h );
+                KPixmapEffect::gradient( *pixmaps[ widget ], *grHighColors[ widget ],
+                                         *grLowColors[ widget ],
+                                         KPixmapEffect::VerticalGradient );
+            }
+        }
+    }
+    else if ( gradients[ widget ] == GrHorizontal )
+    {
+        if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w )
+        {
+            KThemePixmap * cachePix = cache->horizontalPixmap( w, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ],
+                                   KThemeCache::HorizontalScale, widget );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ],
+                                   KThemeCache::HorizontalScale, widget );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->resize( w, h );
+                KPixmapEffect::gradient( *pixmaps[ widget ], *grHighColors[ widget ],
+                                         *grLowColors[ widget ],
+                                         KPixmapEffect::HorizontalGradient );
+            }
+        }
+    }
+    else if ( gradients[ widget ] == GrReverseBevel )
+    {
+        if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
+                pixmaps[ widget ] ->height() != h )
+        {
+            KThemePixmap * cachePix = cache->pixmap( w, h, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::FullScale,
+                                   widget );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::FullScale,
+                                   widget );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->resize( w, h );
+
+                KPixmap s;
+                int offset = decoWidth( widget );
+                s.resize( w - offset * 2, h - offset * 2 );
+                TQColor lc( *grLowColors[ widget ] );
+                TQColor 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 );
+                }
+                KPixmapEffect::gradient( *pixmaps[ widget ],
+                                         lc, hc,
+                                         KPixmapEffect::DiagonalGradient );
+                KPixmapEffect::gradient( s, *grHighColors[ widget ],
+                                         *grLowColors[ widget ],
+                                         KPixmapEffect::DiagonalGradient );
+                bitBlt( pixmaps[ widget ], offset, offset, &s, 0, 0, w - offset * 2,
+                        h - offset * 2, TQt::CopyROP );
+            }
+        }
+    }
+    else
+    {
+        KPixmapEffect::GradientType g;
+        switch ( gradients[ widget ] )
+        {
+            case GrPyramid:
+                g = KPixmapEffect::PyramidGradient;
+                break;
+            case GrRectangle:
+                g = KPixmapEffect::RectangleGradient;
+                break;
+            case GrElliptic:
+                g = KPixmapEffect::EllipticGradient;
+                break;
+            default:
+                g = KPixmapEffect::DiagonalGradient;
+                break;
+        }
+        if ( !pixmaps[ widget ] || pixmaps[ widget ] ->width() != w ||
+                pixmaps[ widget ] ->height() != h )
+        {
+            KThemePixmap * cachePix = cache->pixmap( w, h, widget );
+            if ( cachePix )
+            {
+                cachePix = new KThemePixmap( *cachePix );
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::FullScale,
+                                   widget );
+                pixmaps[ widget ] = cachePix;
+            }
+            else
+            {
+                if ( pixmaps[ widget ] )
+                    cache->insert( pixmaps[ widget ], KThemeCache::FullScale,
+                                   widget );
+                pixmaps[ widget ] = new KThemePixmap;
+                pixmaps[ widget ] ->resize( w, h );
+                KPixmapEffect::gradient( *pixmaps[ widget ], *grHighColors[ widget ],
+                                         *grLowColors[ widget ], g );
+            }
+        }
+    }
+    return ( pixmaps[ widget ] );
+}
+
+KThemePixmap* KThemeBase::scalePixmap( int w, int h, WidgetType widget ) const
+{
+
+    if ( gradients[ widget ] && blends[ widget ] == 0.0 )
+        return ( gradient( w, h, widget ) );
+
+    return ( scale( w, h, widget ) );
+}
+
+TQColorGroup* KThemeBase::makeColorGroup( const TQColor &fg, const TQColor &bg,
+        TQt::GUIStyle )
+{
+    if ( shading == Motif )
+    {
+        int highlightVal, lowlightVal;
+        highlightVal = 100 + ( 2 * d->contrast + 4 ) * 16 / 10;
+        lowlightVal = 100 + ( ( 2 * d->contrast + 4 ) * 10 );
+        return ( new TQColorGroup( fg, bg, bg.light( highlightVal ),
+                                  bg.dark( lowlightVal ), bg.dark( 120 ),
+                                  fg, TQApplication::palette().active().base() ) );
+    }
+    else
+        return ( new TQColorGroup( fg, bg, bg.light( 150 ), bg.dark(),
+                                  bg.dark( 120 ), fg,
+                                  TQApplication::palette().active().base() ) );
+}
+
+
+void KThemeBase::applyMiscResourceGroup( TQSettings *config )
+{
+#ifndef Q_WS_QWS //FIXME
+    d->props.erase( "Misc" ); // clear the old property
+
+    TQString base = configFileName + "Misc/";
+
+    Prop& prop = d->props[ "Misc" ];
+    TQString tmpStr;
+
+    tmpStr = config->readEntry( base + "SButtonPosition" );
+    if ( tmpStr == "BottomLeft" )
+        prop[ "SButtonPosition" ] = TQString::number( ( int ) SBBottomLeft );
+    else if ( tmpStr == "BottomRight" )
+        prop[ "SButtonPosition" ] = TQString::number( ( int ) SBBottomRight );
+    else
+    {
+        if ( tmpStr != "Opposite" && !tmpStr.isEmpty() )
+            tqWarning( "KThemeBase: Unrecognized sb button option %s, using Opposite.\n", tmpStr.latin1() );
+        ;
+        prop[ "SButtonPosition" ] = TQString::number( ( int ) SBOpposite );
+    }
+    tmpStr = config->readEntry( base + "ArrowType" );
+    if ( tmpStr == "Small" )
+        prop[ "ArrowType" ] = TQString::number( ( int ) SmallArrow );
+    else if ( tmpStr == "3D" )
+        prop[ "ArrowType" ] = TQString::number( ( int ) MotifArrow );
+    else
+    {
+        if ( tmpStr != "Normal" && !tmpStr.isEmpty() )
+            tqWarning( "KThemeBase: Unrecognized arrow option %s, using Normal.\n", tmpStr.latin1() );
+        prop[ "ArrowType" ] = TQString::number( ( int ) LargeArrow );
+    }
+    tmpStr = config->readEntry( base + "ShadeStyle" );
+    if ( tmpStr == "Motif" )
+        prop[ "ShadeStyle" ] = TQString::number( ( int ) Motif );
+    else if ( tmpStr == "Next" )
+        prop[ "ShadeStyle" ] = TQString::number( ( int ) Next );
+    else if ( tmpStr == "KDE" )
+        prop[ "ShadeStyle" ] = TQString::number( ( int ) KDE );
+    else
+        prop[ "ShadeStyle" ] = TQString::number( ( int ) Windows );
+
+    prop[ "FrameWidth" ] = TQString::number( config->readNumEntry( base + "FrameWidth", 2 ) );
+    prop[ "Cache" ] = TQString::number( config->readNumEntry( base + "Cache", 1024 ) );
+    prop[ "ScrollBarExtent" ] = TQString::number( config->readNumEntry( base + "ScrollBarExtent", 16 ) );
+#endif
+}
+
+static int readNumEntry( Prop& prop, TQString setting, int def )
+{
+    bool ok;
+    TQString s_val = prop[ setting ];
+    int val = s_val.toInt( &ok );
+    if ( ok )
+        return val;
+    return def;
+}
+
+static TQColor readColorEntry( Prop& prop, TQString setting, const TQColor& def )
+{
+    TQString s_val = prop[ setting ];
+    if ( !s_val.isEmpty() )
+    {
+        TQColor c( s_val );
+        return c;
+    }
+    return def;
+}
+
+void KThemeBase::readMiscResourceGroup()
+{
+#ifndef Q_WS_QWS //FIXME
+    Prop & prop = d->props[ "Misc" ];
+
+    sbPlacement = ( SButton ) readNumEntry( prop, "SButtonPosition",
+                                            ( int ) SBOpposite );
+    arrowStyle = ( ArrowStyle ) readNumEntry( prop, "ArrowType",
+                 ( int ) LargeArrow );
+    shading = ( ShadeStyle ) readNumEntry( prop, "ShadeStyle", ( int ) Windows );
+    defaultFrame = readNumEntry( prop, "FrameWidth", 2 );
+    cacheSize = readNumEntry( prop, "Cache", 1024 );
+    sbExtent = readNumEntry( prop, "ScrollBarExtent", 16 );
+#endif
+}
+
+
+void KThemeBase::applyResourceGroup( TQSettings *config, int i )
+{
+#ifndef Q_WS_QWS //FIXME
+    TQString tmpStr;
+    int tmpVal;
+
+    // clear the old property
+    d->props.erase( widgetEntries[ i ] );
+
+    TQString base = configFileName + widgetEntries[ i ] + "/";
+
+    Prop& prop = d->props[ widgetEntries[ i ] ];
+
+    tmpStr = config->readEntry( base + "CopyWidget", "" );
+    prop[ "CopyWidget" ] = tmpStr;
+    if ( !tmpStr.isEmpty() )
+    {
+        return ;
+    }
+
+    tmpStr = config->readEntry( base + "Scale" );
+    if ( tmpStr == "Full" )
+        tmpVal = ( int ) FullScale;
+    else if ( tmpStr == "Horizontal" )
+        tmpVal = ( int ) HorizontalScale;
+    else if ( tmpStr == "Vertical" )
+        tmpVal = ( int ) VerticalScale;
+    else
+    {
+        if ( tmpStr != "Tile" && !tmpStr.isEmpty() )
+            tqWarning( "KThemeBase: Unrecognized scale option %s, using Tile.\n", tmpStr.latin1() );
+        tmpVal = ( int ) TileScale;
+    }
+    prop[ "ScaleHint" ] = TQString::number( tmpVal );
+
+    // Gradient type
+    tmpStr = config->readEntry( base + "Gradient" );
+    if ( tmpStr == "Diagonal" )
+        tmpVal = ( int ) GrDiagonal;
+    else if ( tmpStr == "Horizontal" )
+        tmpVal = ( int ) GrHorizontal;
+    else if ( tmpStr == "Vertical" )
+        tmpVal = ( int ) GrVertical;
+    else if ( tmpStr == "Pyramid" )
+        tmpVal = ( int ) GrPyramid;
+    else if ( tmpStr == "Rectangle" )
+        tmpVal = ( int ) GrRectangle;
+    else if ( tmpStr == "Elliptic" )
+        tmpVal = ( int ) GrElliptic;
+    else if ( tmpStr == "ReverseBevel" )
+        tmpVal = ( int ) GrReverseBevel;
+    else
+    {
+        if ( tmpStr != "None" && !tmpStr.isEmpty() )
+            tqWarning( "KThemeBase: Unrecognized gradient option %s, using None.\n", tmpStr.latin1() );
+        tmpVal = ( int ) GrNone;
+    }
+    prop[ "Gradient" ] = TQString::number( tmpVal );
+
+    // Blend intensity
+    tmpStr.setNum( config->readDoubleEntry( base + "BlendIntensity", 0.0 ) );
+    prop[ "Blend" ] = tmpStr;
+
+    // Bevel contrast
+    prop[ "BContrast" ] = TQString::number( config->readNumEntry( base + "BevelContrast", 0 ) );
+
+    // Border width
+    prop[ "Border" ] = TQString::number( config->readNumEntry( base + "Border", 1 ) );
+
+    // Highlight width
+    prop[ "Highlight" ] = TQString::number( config->readNumEntry( base + "Highlight", 1 ) );
+
+    TQStringList keys = config->entryList( base );
+
+    // Gradient low color or blend background
+    if ( keys.contains( "GradientLow" ) )
+        prop[ "GrLow" ] = readColorEntry( config, TQString( base + "GradientLow" ).latin1(),
+                                          &TQApplication::palette().active().background() ).name();
+
+    // Gradient high color
+    if ( keys.contains( "GradientHigh" ) )
+        prop[ "GrHigh" ] = readColorEntry( config, TQString( base + "GradientHigh" ).latin1(),
+                                           &TQApplication::palette().active().foreground() ).name();
+
+    // Extended color attributes
+    if ( keys.contains( "Foreground" ) || keys.contains( "Background" ) )
+    {
+        TQColor fg, bg;
+        if ( keys.contains( "Background" ) )
+            bg = readColorEntry( config, TQString( base + "Background" ).latin1(), &bg );
+        if ( keys.contains( "Foreground" ) )
+            fg = readColorEntry( config, TQString( base + "Foreground" ).latin1(), &fg );
+        prop[ "Foreground" ] = fg.name();
+        prop[ "Background" ] = bg.name();
+
+    }
+    else
+        colors[ i ] = NULL;
+
+    // Pixmap
+    tmpStr = config->readEntry( base + "Pixmap", "" );
+    if ( !tmpStr.isEmpty() )
+        prop[ "Pixmap" ] = tmpStr;
+    // Pixmap border
+    tmpStr = config->readEntry( base + "PixmapBorder", "" );
+    if ( !tmpStr.isEmpty() )
+    {
+        prop[ "PixmapBorder" ] = tmpStr;
+        prop[ "PixmapBWidth" ] = TQString::number(
+                                     config->readNumEntry( base + "PixmapBWidth", 0 ) );
+    }
+
+    // Various widget specific settings. This was more efficient when bunched
+    // together in the misc group, but this makes an easier to read config.
+    if ( i == SliderGroove )
+        prop[ "SmallGroove" ] = TQString::number(
+                                    config->readBoolEntry( base + "SmallGroove", false ) );
+    else if ( i == ActiveTab || i == InactiveTab )
+        prop[ "BottomLine" ] = TQString::number(
+                                   config->readBoolEntry( base + "BottomLine", true ) );
+    else if ( i == Splitter )
+        prop[ "Width" ] = TQString::number( config->readNumEntry( base + "Width", 10 ) );
+    else if ( i == ComboBox || i == ComboBoxDown )
+    {
+        if ( keys.contains( "Round" ) )
+            prop[ "Round" ] = TQString::number( config->readBoolEntry( base + "Round", false ) );
+        else
+            prop[ "Round" ] = "5000"; // invalid, used w/multiple groups
+
+    }
+    else if ( i == PushButton || i == PushButtonDown )
+    {
+        if ( keys.contains( "XShift" ) )
+            prop[ "XShift" ] = TQString::number( config->readNumEntry( base + "XShift", 0 ) );
+        else
+            prop[ "XShift" ] = "5000";
+        if ( keys.contains( "YShift" ) )
+            prop[ "YShift" ] = TQString::number( config->readNumEntry( base + "YShift", 0 ) );
+        else
+            prop[ "YShift" ] = "5000";
+        if ( keys.contains( "3DFocusRect" ) )
+            prop[ "3DFRect" ] = TQString::number( config->
+                                                 readBoolEntry(  base + "3DFocusRect", false ) );
+        else
+            prop[ "3DFRect" ] = "5000";
+        if ( keys.contains( "3DFocusOffset" ) )
+            prop[ "3DFOffset" ] = TQString::number( config->
+                                                   readBoolEntry(  base + "3DFocusOffset", 0 ) );
+        else
+            prop[ "3DFOffset" ] = "5000";
+        if ( keys.contains( "Round" ) )
+            prop[ "Round" ] = TQString::number( config->readBoolEntry( base + "Round", false ) );
+        else
+            prop[ "Round" ] = "5000";
+    }
+#endif
+}
+
+void KThemeBase::readResourceGroup( int i, TQString *pixnames, TQString *brdnames,
+                                    bool *loadArray )
+{
+#ifndef Q_WS_QWS //FIXME
+    if ( loadArray[ i ] == true )
+    {
+        return ; // already been preloaded.
+    }
+
+    int tmpVal;
+    Prop prop = d->props[ widgetEntries[ i ] ];
+    TQString tmpStr;
+
+    tmpStr = prop[ "CopyWidget" ];
+    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, pixnames, brdnames,
+                                       loadArray );
+                break;
+            }
+        }
+        if ( loadArray[ sIndex ] )
+        {
+            copyWidgetConfig( sIndex, i, pixnames, brdnames );
+        }
+        else
+            tqWarning( "KThemeBase: 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 = prop[ "Pixmap" ];
+            if ( tmpStr.isEmpty() )
+            {
+                copyWidgetConfig( ArrowUp + ( tmpVal - DisArrowUp ), i, pixnames,
+                                  brdnames );
+                return ;
+            }
+        }
+    }
+
+    // Scale hint
+    scaleHints[ i ] = ( ScaleHint ) readNumEntry( prop, "ScaleHint", ( int ) TileScale );
+    gradients[ i ] = ( Gradient ) readNumEntry( prop, "Gradient", ( int ) GrNone );
+
+    // Blend intensity
+    tmpStr = prop[ "Blend" ];
+    if ( tmpStr.isEmpty() )
+        tmpStr = TQString::fromLatin1( "0.0" );
+    blends[ i ] = tmpStr.toFloat();
+
+    // Bevel contrast
+    bContrasts[ i ] = readNumEntry( prop, "BContrast", 0 );
+
+    // Border width
+    borders[ i ] = readNumEntry( prop, "Border", 1 );
+
+    // Highlight width
+    highlights[ i ] = readNumEntry( prop, "Highlight", 1 );
+
+    // Gradient low color or blend background
+    if ( gradients[ i ] != GrNone || blends[ i ] != 0.0 )
+        grLowColors[ i ] =
+            new TQColor( readColorEntry( prop, "GrLow",
+                                        TQApplication::palette().active().
+                                        background() ) );
+    else
+        grLowColors[ i ] = NULL;
+
+    // Gradient high color
+    if ( gradients[ i ] != GrNone )
+        grHighColors[ i ] =
+            new TQColor( readColorEntry( prop, "GrHigh",
+                                        TQApplication::palette().active().
+                                        background() ) );
+    else
+        grHighColors[ i ] = NULL;
+
+    // Extended color attributes
+    TQColor fg, bg;
+    fg = readColorEntry( prop, "Foreground", fg );
+    bg = readColorEntry( prop, "Background", bg );
+    if ( fg.isValid() || bg.isValid() )
+    {
+        if ( !fg.isValid() )
+            fg = TQApplication::palette().active().foreground();
+        if ( !bg.isValid() )
+            bg = TQApplication::palette().active().background();
+        colors[ i ] = makeColorGroup( fg, bg, TQt::WindowsStyle );
+    }
+    else
+        colors[ i ] = NULL;
+
+    // Pixmap
+    int existing;
+    tmpStr = prop[ "Pixmap" ];
+    pixnames[ i ] = tmpStr;
+    duplicate[ i ] = false;
+    pixmaps[ i ] = NULL;
+    images[ i ] = NULL;
+    // Scan for duplicate pixmaps(two identical pixmaps, tile scale, no blend,
+    // no pixmapped border)
+    if ( !tmpStr.isEmpty() )
+    {
+        for ( existing = 0; existing < i; ++existing )
+        {
+            if ( tmpStr == 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 ] && !tmpStr.isEmpty() )
+    {
+        pixmaps[ i ] = loadPixmap( tmpStr );
+        // 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( tmpStr );
+    }
+
+    // Pixmap border
+    tmpStr = prop[ "PixmapBorder" ];
+    brdnames[ i ] = tmpStr;
+    pbDuplicate[ i ] = false;
+    pbPixmaps[ i ] = NULL;
+    pbWidth[ i ] = 0;
+    if ( !tmpStr.isEmpty() )
+    {
+        pbWidth[ i ] = readNumEntry( prop, "PixmapBWidth", 0 );
+        if ( pbWidth[ i ] == 0 )
+        {
+            tqWarning( "KThemeBase: No border width specified for pixmapped border widget %s\n",
+                      widgetEntries[ i ] );
+            tqWarning( "KThemeBase: Using default of 2.\n" );
+            pbWidth[ i ] = 2;
+        }
+        // duplicate check
+        for ( existing = 0; existing < i; ++existing )
+        {
+            if ( tmpStr == brdnames[ existing ] )
+            {
+                pbPixmaps[ i ] = pbPixmaps[ existing ];
+                pbDuplicate[ i ] = true;
+                break;
+            }
+        }
+    }
+    // load
+    if ( !pbDuplicate[ i ] && !tmpStr.isEmpty() )
+        pbPixmaps[ i ] = loadPixmap( tmpStr );
+
+    if ( pbPixmaps[ i ] && !pbDuplicate[ i ] )
+        generateBorderPix( i );
+
+    // Various widget specific settings. This was more efficient when bunched
+    // together in the misc group, but this makes an easier to read config.
+    if ( i == SliderGroove )
+        roundedSlider = readNumEntry( prop, "SmallGroove", false );
+    else if ( i == ActiveTab )
+        aTabLine = readNumEntry( prop, "BottomLine", true );
+    else if ( i == InactiveTab )
+        iTabLine = readNumEntry( prop, "BottomLine", true );
+    else if ( i == Splitter )
+        splitterWidth = readNumEntry( prop, "Width", 10 );
+    else if ( i == ComboBox || i == ComboBoxDown )
+    {
+        tmpVal = readNumEntry( prop, "Round", 5000 );
+        if ( tmpVal != 5000 )
+            roundedCombo = tmpVal;
+    }
+    else if ( i == PushButton || i == PushButtonDown )
+    {
+        tmpVal = readNumEntry( prop, "XShift", 0 );
+        if ( tmpVal != 5000 )
+            btnXShift = tmpVal;
+        tmpVal = readNumEntry( prop, "YShift", 0 );
+        if ( tmpVal != 5000 )
+            btnYShift = tmpVal;
+        tmpVal = readNumEntry( prop, "3DFRect", false );
+        if ( tmpVal != 5000 )
+            focus3D = tmpVal;
+        tmpVal = readNumEntry( prop, "3DFOffset", 0 );
+        if ( tmpVal != 5000 )
+            focus3DOffset = tmpVal;
+        tmpVal = readNumEntry( prop, "Round", false );
+        if ( tmpVal != 5000 )
+            roundedButton = tmpVal;
+    }
+    loadArray[ i ] = true;
+#endif
+}
+
+
+TQPalette KThemeBase::overridePalette( const TQPalette& pal )
+{
+
+    //Read current settings for colors..
+    TQColor background = pal.active().background();
+    TQColor foreground = pal.active().foreground();
+    TQColor button = background; //CHECKME
+    TQColor highlight = pal.active().highlight();
+    TQColor highlightedText = pal.active().highlightedText(); //CHECKME
+    TQColor base = pal.active().base(); //config->readColorEntry( "windowBackground", &white );
+    TQColor baseText = pal.active().text(); //CHECKME
+
+    //See whether there are any immediate overrides.
+    if ( d->overrideBackground )
+        background = d->overrideBackgroundCol;
+
+    if ( d->overrideForeground )
+        foreground = d->overrideForegroundCol;
+
+    if ( d->overrideSelectBackground )
+        highlight = d->overrideSelectBackgroundCol;
+    if ( d->overrideSelectForeground )
+        highlightedText = d->overrideSelectForegroundCol;
+
+    if ( d->overrideWindowBackground )
+        base = d->overrideWindowBackgroundCol;
+    if ( d->overrideWindowForeground )
+        baseText = d->overrideWindowForegroundCol;
+
+    //Now, try to get the button color from the pixmap
+    if ( uncached( Bevel ) )
+        button = d->pixmapAveColor( uncached( Bevel ) );
+
+    TQColor buttonText = foreground;
+
+    int highlightVal, lowlightVal;
+    highlightVal = 100 + ( 2 * d->contrast + 4 ) * 16 / 10;
+    lowlightVal = 100 + ( 2 * d->contrast + 4 ) * 10;
+
+
+    if ( isPixmap( Background ) || isColor( Background ) )
+    {
+        if ( isColor( Background ) )
+        {
+            background = colorGroup( pal.active(), Background )
+                         ->background();
+        }
+        if ( isPixmap( Background ) )
+        {
+            background = d->pixmapAveColor( uncached( Background ) );
+        }
+
+
+        TQColorGroup pre( foreground, button, background.light( highlightVal ),
+                            background.dark( lowlightVal ), background.dark( 120 ),
+                            baseText, buttonText /*CHECKME: BrightText*/, base, background );
+
+        buttonText = colorGroup( pre, PushButton ) ->foreground();
+    }
+
+    TQColor disfg = foreground;
+    int h, s, v;
+    disfg.hsv( &h, &s, &v );
+    if ( v > 128 )
+        // dark bg, light fg - need a darker disabled fg
+        disfg = disfg.dark( lowlightVal );
+    else if ( disfg != black )
+        // light bg, dark fg - need a lighter disabled fg - but only if !black
+        disfg = disfg.light( highlightVal );
+    else
+        // black fg - use darkgray disabled fg
+        disfg = Qt::darkGray;
+
+
+    TQColorGroup disabledgrp( disfg, background,   //TODO:Convert this to the new ctor.
+                             background.light( highlightVal ),
+                             background.dark( lowlightVal ),
+                             background.dark( 120 ),
+                             background.dark( 120 ), base );
+
+
+    TQColorGroup colgrp( foreground, button, background.light( highlightVal ),
+                        background.dark( lowlightVal ), background.dark( 120 ),
+                        baseText, buttonText /*CHECKME: BrightText*/, base, background );
+
+
+
+    colgrp.setColor( TQColorGroup::Highlight, highlight );
+    colgrp.setColor( TQColorGroup::HighlightedText, highlightedText );
+    colgrp.setColor( TQColorGroup::ButtonText, buttonText );
+    colgrp.setColor( TQColorGroup::Midlight, button.light( 110 ) );
+
+
+    disabledgrp.setColor( TQColorGroup::Base, base );
+    disabledgrp.setColor( TQColorGroup::Button, button );
+    disabledgrp.setColor( TQColorGroup::ButtonText, buttonText );
+    disabledgrp.setColor( TQColorGroup::Midlight, button.light( 110 ) );
+
+    TQPalette newPal( colgrp, disabledgrp, colgrp );
+
+    return newPal;
+
+}
+
+KThemePixmap::KThemePixmap( bool timer )
+        : KPixmap()
+{
+    if ( timer )
+    {
+        t = new TQTime;
+        t->start();
+    }
+    else
+        t = NULL;
+    int i;
+    for ( i = 0; i < 8; ++i )
+        b[ i ] = NULL;
+}
+
+KThemePixmap::KThemePixmap( const KThemePixmap &p )
+        : KPixmap( p )
+{
+    if ( p.t )
+    {
+        t = new TQTime;
+        t->start();
+    }
+    else
+        t = NULL;
+    int i;
+    for ( i = 0; i < 8; ++i )
+        if ( p.b[ i ] )
+            b[ i ] = new TQPixmap( *p.b[ i ] );
+        else
+            b[ i ] = NULL;
+}
+
+KThemePixmap::KThemePixmap( const KThemePixmap &p, const TQPixmap &p2 )
+        : KPixmap( p2 )
+{
+    if ( p.t )
+    {
+        t = new TQTime;
+        t->start();
+    }
+    else
+        t = NULL;
+    int i;
+    for ( i = 0; i < 8; ++i )
+        if ( p.b[ i ] )
+            b[ i ] = new TQPixmap( *p.b[ i ] );
+        else
+            b[ i ] = NULL;
+}
+
+
+
+KThemePixmap::~KThemePixmap()
+{
+    if ( t )
+        delete t;
+    int i;
+    for ( i = 0; i < 8; ++i )
+        if ( b[ i ] )
+            delete b[ i ];
+}
+
+KThemeCache::KThemeCache( int maxSize, TQObject *parent, const char *name )
+        : TQObject( parent, name )
+{
+    cache.setMaxCost( maxSize * 1024 );
+    cache.setAutoDelete( true );
+    flushTimer.start( 300000 ); // 5 minutes
+    connect( &flushTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( flushTimeout() ) );
+}
+
+void KThemeCache::flushTimeout()
+{
+    TQIntCacheIterator<KThemePixmap> it( cache );
+    while ( it.current() )
+    {
+        if ( it.current() ->isOld() )
+            cache.remove( it.currentKey() );
+        else
+            ++it;
+    }
+}
+
+KThemePixmap* KThemeCache::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;
+
+    KThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
+    if ( pix )
+        pix->updateAccessed();
+    return ( pix );
+}
+
+KThemePixmap* KThemeCache::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;
+    KThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
+    if ( pix )
+        pix->updateAccessed();
+    return ( pix );
+}
+
+KThemePixmap* KThemeCache::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;
+    KThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
+    if ( pix )
+        pix->updateAccessed();
+    return ( pix );
+}
+
+bool KThemeCache::insert( KThemePixmap *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"