|
|
/*
|
|
|
$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) 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( &tmp, 0, 0, pbPixmaps[ i ], 0, 0, pbWidth[ i ], pbWidth[ i ],
|
|
|
TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], pbPixmaps[ i ] ->width() - pbWidth[ i ], 0,
|
|
|
pbWidth[ i ], pbWidth[ i ], TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], 0, pbPixmaps[ i ] ->height() - pbWidth[ i ],
|
|
|
pbWidth[ i ], pbWidth[ i ], TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], pbPixmaps[ i ] ->width() - pbWidth[ i ],
|
|
|
pbPixmaps[ i ] ->height() - pbWidth[ i ], pbWidth[ i ], pbWidth[ i ],
|
|
|
TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], pbWidth[ i ], 0,
|
|
|
pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], pbWidth[ i ],
|
|
|
pbPixmaps[ i ] ->height() - pbWidth[ i ],
|
|
|
pbPixmaps[ i ] ->width() - pbWidth[ i ] * 2, pbWidth[ i ], TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], 0, pbWidth[ i ], pbWidth[ i ],
|
|
|
pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2, TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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( &tmp, 0, 0, pbPixmaps[ i ], pbPixmaps[ i ] ->width() - pbWidth[ i ],
|
|
|
pbWidth[ i ], pbWidth[ i ], pbPixmaps[ i ] ->height() - pbWidth[ i ] * 2,
|
|
|
TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
{
|
|
|
bitBlt( &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 TQ_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 TQ_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( pixmap, 0, 0, tmp, 0, 0, bdWidth, bdWidth,
|
|
|
TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
bitBlt( &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( pixmap, w - bdWidth, 0, tmp, 0, 0, bdWidth,
|
|
|
bdWidth, TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
bitBlt( &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( pixmap, 0, h - bdWidth, tmp, 0, 0, bdWidth,
|
|
|
bdWidth, TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
bitBlt( &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( pixmap, w - bdWidth, h - bdWidth, tmp, 0, 0,
|
|
|
bdWidth, bdWidth, TQt::CopyROP, false );
|
|
|
if ( srcMask )
|
|
|
bitBlt( &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( &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( &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( &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( &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 TQ_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 TQ_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 TQ_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 TQ_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 = TQt::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, TQ_SIGNAL( timeout() ), TQ_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"
|
