TDE
/
rosegarden
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/rosegarden
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '832eb69d57'
${ noResults }
rosegarden/src/gui/kdeext/klearlook.cpp

4096 lines
174 KiB
Raw Normal View History Unescape

Added old abandoned KDE3 version of the RoseGarden MIDI tool git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/rosegarden@1097595 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
15 years ago
/* $Id: klearlook.cpp,v 1.25 2006/04/26 18:55:41 jck Exp $
Klearlook (C) Joerg C. Koenig, 2005 jck@gmx.org
----
Based upon QtCurve (C) Craig Drummond, 2003 Craig.Drummond@lycos.co.uk
Bernhard Rosenkr<EFBFBD>zer <bero@r?dh?t.com>
Preston Brown <pbrown@r?dh?t.com>
Than Ngo <than@r?dh?t.com>
Released under the GNU General Public License (GPL) v2.
----
B???Curve is based on the KDE Light style, 2nd revision:
Copyright(c)2000-2001 Trolltech AS (info@trolltech.com)
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files(the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <kdeversion.h>
#include <qmenubar.h>
#include <qapplication.h>
#include <qpainter.h>
#include <qpalette.h>
#include <qframe.h>
#include <qpushbutton.h>
#include <qdrawutil.h>
#include <qscrollbar.h>
#include <qtabbar.h>
#include <qtabwidget.h>
#include <qguardedptr.h>
#include <qlayout.h>
#include <qlineedit.h>
#include <qlistview.h>
#include <qbitmap.h>
#include <qcleanuphandler.h>
#include <qimage.h>
#include <qcombobox.h>
#include <qspinbox.h>
#include <qslider.h>
#include <qstylefactory.h>
#include <qcleanuphandler.h>
#include <qcheckbox.h>
#include <qradiobutton.h>
#include <qtoolbutton.h>
#include <qtoolbar.h>
#include <qprogressbar.h>
#include <qcursor.h>
#include <qheader.h>
#include <qwidgetstack.h>
#include <qsplitter.h>
#include <math.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include "klearlook.h"
#include <qsettings.h>
#if KDE_VERSION >= 0x30200
#include <qfile.h>
#include <qdir.h>
#endif
// Uncomment the following to enable gradients in toolbars and menubars
// NOTE: Not yet complete!!!
//#define QTC_GRADIENT_TOOLBARS_AND_MENUBARS
//static int HIGH_LIGHT_FACTORS[]={ 100, 100, 100, 101, 102, 103, 104, 105 /*def*/, 106, 107, 108 };
//#define HIGHLIGHT_FACTOR(X) (X<0||X>10) ? 105 : HIGH_LIGHT_FACTORS[X]
#define QTC_HIGHLIGHT_FACTOR 105
#define QTC_BORDERED_FRAME_WIDTH 2
#define QTC_DEF_FRAME_WIDTH 1
//#define QTC_MIN_BTN_SIZE 10
#define QTC_NO_SECT -1
#define MENU_POPUP_ITEM_HIGH_HI 7
#define MENU_POPUP_ITEM_HIGH_LO 5
//#define MENU_POPUP_SHADOW
#define POS_DIV(a, b) ( (a)/(b) + ( ( (a) % (b) >= (b)/2 ) ? 1 : 0 ) )
static const int itemHMargin = 6;
static const int itemFrame = 2;
static const int arrowHMargin = 6;
static const int rightBorder = 12;
#if KDE_VERSION >= 0x30200
// Try to read $KDEHOME/share/config/kickerrc to find out if kicker is transparent...
static QString readEnvPath( const char *env ) {
QCString path = getenv( env );
return path.isEmpty()
? QString::null
: QFile::decodeName( path );
}
static bool kickerIsTrans() {
QString kdeHome( readEnvPath( getuid() ? "KDEHOME" : "KDEROOTHOME" ) ),
cfgFileName;
bool trans = false;
if ( kdeHome.isEmpty() )
cfgFileName = QDir::homeDirPath() + "/.kde/share/config/kickerrc";
else
cfgFileName = QString( kdeHome ) + "/share/config/kickerrc";
QFile cfgFile( cfgFileName );
if ( cfgFile.open( IO_ReadOnly ) ) {
QTextStream stream( &cfgFile );
QString line;
bool stop = false,
inGen = false;
while ( !stream.atEnd() && !stop ) {
line = stream.readLine();
if ( inGen ) {
if ( 0 == line.find( "Transparent=" ) ) // Found it!
{
if ( -1 != line.find( "true" ) )
trans = true;
stop = true;
} else if ( line[ 0 ] == QChar( '[' ) ) // Then wasn't in General section...
stop = true;
} else if ( 0 == line.find( "[General]" ) )
inGen = true;
}
cfgFile.close();
}
return trans;
}
#endif
inline int limit( double c ) {
return c < 0.0
? 0
: c > 255.0
? 255
: ( int ) c;
}
inline QColor midColor( const QColor &a, const QColor &b, double factor = 1.0 ) {
return QColor( ( a.red() + limit( b.red() * factor ) ) >> 1,
( a.green() + limit( b.green() * factor ) ) >> 1,
( a.blue() + limit( b.blue() * factor ) ) >> 1 );
}
// Copied from Keramik...
static bool isFormWidget( const QWidget *widget ) {
//Form widgets are in the KHTMLView, but that has 2 further inner levels
//of widgets - QClipperWidget, and outside of that, QViewportWidget
QWidget * potentialClipPort = widget->parentWidget();
if ( !potentialClipPort || potentialClipPort->isTopLevel() )
return false;
QWidget *potentialViewPort = potentialClipPort->parentWidget();
if ( !potentialViewPort || potentialViewPort->isTopLevel() || qstrcmp( potentialViewPort->name(), "qt_viewport" ) )
return false;
QWidget *potentialKHTML = potentialViewPort->parentWidget();
if ( !potentialKHTML || potentialKHTML->isTopLevel() || qstrcmp( potentialKHTML->className(), "KHTMLView" ) )
return false;
return true;
}
static void rgb2hls( double *r, double *g, double *b )
{
double min;
double max;
double red;
double green;
double blue;
double h, l, s;
double delta;
red = *r;
green = *g;
blue = *b;
if (red > green)
{
if (red > blue)
max = red;
else
max = blue;
if (green < blue)
min = green;
else
min = blue;
}
else
{
if (green > blue)
max = green;
else
max = blue;
if (red < blue)
min = red;
else
min = blue;
}
l = (max + min) / 2;
s = 0;
h = 0;
if (max != min)
{
if (l <= 0.5)
s = (max - min) / (max + min);
else
s = (max - min) / (2 - max - min);
delta = max -min;
if (red == max)
h = (green - blue) / delta;
else if (green == max)
h = 2 + (blue - red) / delta;
else if (blue == max)
h = 4 + (red - green) / delta;
h *= 60;
if (h < 0.0)
h += 360;
}
*r = h;
*g = l;
*b = s;
}
static void hls2rgb( double *h, double *l, double *s ) {
double hue;
double lightness;
double saturation;
double m1, m2;
double r, g, b;
lightness = *l;
saturation = *s;
if (lightness <= 0.5)
m2 = lightness * (1 + saturation);
else
m2 = lightness + saturation - lightness * saturation;
m1 = 2 * lightness - m2;
if (saturation == 0)
{
*h = lightness;
*l = lightness;
*s = lightness;
}
else
{
hue = *h + 120;
while (hue > 360)
hue -= 360;
while (hue < 0)
hue += 360;
if (hue < 60)
r = m1 + (m2 - m1) * hue / 60;
else if (hue < 180)
r = m2;
else if (hue < 240)
r = m1 + (m2 - m1) * (240 - hue) / 60;
else
r = m1;
hue = *h;
while (hue > 360)
hue -= 360;
while (hue < 0)
hue += 360;
if (hue < 60)
g = m1 + (m2 - m1) * hue / 60;
else if (hue < 180)
g = m2;
else if (hue < 240)
g = m1 + (m2 - m1) * (240 - hue) / 60;
else
g = m1;
hue = *h - 120;
while (hue > 360)
hue -= 360;
while (hue < 0)
hue += 360;
if (hue < 60)
b = m1 + (m2 - m1) * hue / 60;
else if (hue < 180)
b = m2;
else if (hue < 240)
b = m1 + (m2 - m1) * (240 - hue) / 60;
else
b = m1;
*h = r;
*l = g;
*s = b;
}
}
static bool equal( double d1, double d2 ) {
return ( fabs( d1 - d2 ) < 0.0001 );
}
static void shade( const QColor &a, QColor *b, float k ) {
if ( equal( k, 1.0 ) )
* b = a;
else {
double red = a.red() / 256.0,
green = a.green() / 256.0,
blue = a.blue() / 256.0;
rgb2hls( &red, &green, &blue );
green *= k;
if ( green > 1.0 )
green = 1.0;
else if ( green < 0.0 )
green = 0.0;
blue *= k;
if ( blue > 1.0 )
blue = 1.0;
else if ( blue < 0.0 )
blue = 0.0;
hls2rgb( &red, &green, &blue );
b->setRgb( limit( red * 256 ), limit( green * 256 ), limit( blue * 256 ) );
}
}
static void shadeGradient( const QColor &base, QColor *vals ) {
vals[ KlearlookStyle::GRADIENT_BASE ] = base;
shade( vals[ KlearlookStyle::GRADIENT_BASE ],
&( vals[ KlearlookStyle::GRADIENT_TOP ] ), SHADE_GRADIENT_TOP );
shade( vals[ KlearlookStyle::GRADIENT_BASE ],
&( vals[ KlearlookStyle::GRADIENT_BOTTOM ] ), SHADE_GRADIENT_BOTTOM );
shade( vals[ KlearlookStyle::GRADIENT_BASE ],
&( vals[ KlearlookStyle::GRADIENT_LIGHT ] ), SHADE_GRADIENT_LIGHT );
shade( vals[ KlearlookStyle::GRADIENT_BASE ],
&( vals[ KlearlookStyle::GRADIENT_DARK ] ), SHADE_GRADIENT_DARK );
}
static void drawLines( QPainter *p, const QRect &r, bool horiz, int nLines, int offset, const QColor *cols,
int startOffset, bool etched, bool lightGradient ) {
int space = ( nLines * 2 ) + ( nLines - 1 ),
x = horiz ? r.x() : r.x() + ( ( r.width() - space ) >> 1 ),
y = horiz ? r.y() + ( ( r.height() - space ) >> 1 ) : r.y(),
x2 = r.x() + r.width() - 1,
y2 = r.y() + r.height() - 1,
i,
displacement = etched ? 1 : 0;
if ( horiz ) {
if ( startOffset && y + startOffset > 0 )
y += startOffset;
p->setPen( cols[ etched ? lightGradient ? 3 : 4 : 0 ] );
for ( i = 0; i < space; i += 3 )
p->drawLine( x + offset, y + i, x2 - ( offset + displacement ), y + i );
p->setPen( cols[ etched ? 0 : lightGradient ? 3 : 4 ] );
for ( i = 1; i < space; i += 3 )
p->drawLine( x + offset + displacement, y + i - 2, x2 - offset, y + i - 2);
} else {
if ( startOffset && x + startOffset > 0 )
x += startOffset;
p->setPen( cols[ etched ? lightGradient ? 3 : 4 : 0 ] );
for ( i = 0; i < space; i += 3 )
p->drawLine( x + i, y + offset, x + i, y2 - ( offset + displacement ) );
p->setPen( cols[ etched ? 0 : lightGradient ? 3 : 4 ] );
for ( i = 1; i < space; i += 3 )
p->drawLine( x + i -2, y + offset + displacement, x + i -2, y2 - offset );
}
}
inline QColor getFill( QStyle::SFlags flags, const QColor *use ) {
return !( flags & QStyle::Style_Enabled )
? use[ 1 ]
: flags & QStyle::Style_Down
? use[ 3 ]
: flags & QStyle::Style_MouseOver
? flags & ( QStyle::Style_On | QStyle::Style_Sunken )
? use[ 3 ].light( QTC_HIGHLIGHT_FACTOR )
: use[ NUM_SHADES ].light( QTC_HIGHLIGHT_FACTOR )
: flags & ( QStyle::Style_On | QStyle::Style_Sunken )
? use[ 3 ]
: use[ NUM_SHADES ];
}
#ifdef USE_SINGLE_STYLE
KlearlookStyle::KlearlookStyle()
#else
KlearlookStyle::KlearlookStyle(
bool gpm, bool bb, bool bf, bool round, EGroove st, h,
bool ge, bool va, bool bdt, bool crlh, EDefBtnIndicator dbi, ETBarBorder tbb,
ELvExpander lve, ELvLines lvl, bool lvd, bool ico, int popuplvl ) )
#endif
: KStyle( AllowMenuTransparency, WindowsStyleScrollBar ),
themedApp( APP_OTHER ),
#ifndef USE_SINGLE_STYLE
borderButton( bb ), borderFrame( bf ), rounded( round ), etchedSlider( etched ), appearance( ge ? APPEARANCE_GRADIENT : APPEARANCE_FLAT ),
pmProfile( PROFILE_SUNKEN ), vArrow( va ), boldDefText( bdt ), crLabelHighlight( crlh ), lvDark( lvd ),
defBtnIndicator( dbi ), sliderThumbs( st ), handles( h ), toolbarBorders( tbb ), lvExpander( lve ), lvLines( lvl ), menuIcons( ico ), borderSplitter( true ), popupmenuHighlightLevel(popuplvl)
#endif
#if KDE_VERSION >= 0x30200
isTransKicker( false ),
#endif
hover( HOVER_NONE ),
oldCursor( -1, -1 ),
formMode( false ),
hoverWidget( NULL ),
hoverSect( QTC_NO_SECT ) {
QSettings s;
contrast = s.readNumEntry( "/Qt/KDE/contrast", 7 );
if ( contrast < 0 || contrast > 10 )
contrast = 7;
#ifdef USE_SINGLE_STYLE
borderButton = borderFrame = s.readBoolEntry( "/klearlookstyle/Settings/border", true );
rounded = borderButton ? s.readBoolEntry( "/klearlookstyle/Settings/round", true ) : false;
menuIcons = s.readBoolEntry( "/klearlookstyle/Settings/icons", true );
darkMenubar = s.readBoolEntry( "/klearlookstyle/Settings/darkMenubar", true );
popupmenuHighlightLevel = s.readNumEntry( "/klearlookstyle/Settings/popupmenuHighlightLevel", 3);
QString tmp = s.readEntry( "/klearlookstyle/Settings/toolbarBorders", QString::null );
toolbarBorders = tmp.isEmpty()
? TB_LIGHT
: qtc_to_tbar_border( tmp.latin1() );
bool etched = s.readBoolEntry( "/klearlookstyle/Settings/etched", true );
tmp = s.readEntry( "/klearlookstyle/Settings/sliderThumbs", QString::null );
sliderThumbs = tmp.isEmpty()
? etched ? GROOVE_SUNKEN : GROOVE_RAISED
: qtc_to_groove( tmp.latin1() );
tmp = s.readEntry( "/klearlookstyle/Settings/lvExpander", QString::null );
lvExpander = tmp.isEmpty()
? LV_EXP_ARR
: qtc_to_lv_expander( tmp.latin1() );
tmp = s.readEntry( "/klearlookstyle/Settings/lvLines", QString::null );
lvLines = tmp.isEmpty()
? LV_LINES_SOLID
: qtc_to_lv_lines( tmp.latin1() );
lvDark = s.readBoolEntry( "/klearlookstyle/Settings/lvDark", false );
handles = qtc_to_groove( s.readEntry( "/klearlookstyle/Settings/sliderThumbs", DEF_HANDLE_STR ).latin1() );
if ( GROOVE_NONE == handles )
handles = GROOVE_RAISED;
appearance = qtc_to_appearance(
s.readEntry( "/klearlookstyle/Settings/appearance", DEF_APPEARANCE_STR ).latin1() );
pmProfile = qtc_to_profile( s.readEntry( "/klearlookstyle/Settings/pm", DEF_PROFILE_STR ).latin1() );
vArrow = s.readBoolEntry( "/klearlookstyle/Settings/vArrow", false );
boldDefText = s.readBoolEntry( "/klearlookstyle/Settings/embolden", false );
crLabelHighlight = s.readBoolEntry( "/klearlookstyle/Settings/crLabelHighlight", false );
defBtnIndicator = qtc_to_ind(
s.readEntry( "/klearlookstyle/Settings/defBtnIndicator", DEF_IND_STR ).latin1() );
//if(!boldDefText && IND_NONE==defBtnIndicator)
// defBtnIndicator=IND_CORNER;
borderSplitter = s.readBoolEntry( "/klearlookstyle/Settings/borderSplitter", false );
#endif
if ( PROFILE_RAISED != pmProfile )
shadeColors( qApp->palette().active().highlight(), menuPbar );
else
shadeGradient( qApp->palette().active().highlight(), menuPbar );
shadeColors( qApp->palette().active().background(), gray );
shadeColors( qApp->palette().active().button(), button );
}
void KlearlookStyle::polish( QApplication *app ) {
if ( !qstrcmp( app->argv() [ 0 ], "kicker" ) || !qstrcmp( app->argv() [ 0 ], "appletproxy" ) ) {
themedApp = APP_KICKER;
#if KDE_VERSION >= 0x30200
isTransKicker = rounded && kickerIsTrans();
#endif
} else if ( !qstrcmp( app->argv() [ 0 ], "korn" ) ) {
themedApp = APP_KORN;
#if KDE_VERSION >= 0x30200
isTransKicker = rounded && kickerIsTrans();
#endif
} else
themedApp = qstrcmp( qApp->argv() [ 0 ], "soffice.bin" ) ? APP_OTHER : APP_OPENOFFICE;
}
void KlearlookStyle::polish( QPalette &pal ) {
int c = QSettings().readNumEntry( "/Qt/KDE/contrast", 7 );
bool newContrast = false;
if ( c < 0 || c > 10 )
c = 7;
if ( c != contrast ) {
contrast = c;
newContrast = true;
}
if ( newContrast || gray[ NUM_SHADES ] != qApp->palette().active().background() )
shadeColors( qApp->palette().active().background(), gray );
if ( newContrast || button[ NUM_SHADES ] != qApp->palette().active().button() )
shadeColors( qApp->palette().active().button(), button );
if ( PROFILE_RAISED == pmProfile ) {
if ( newContrast || menuPbar[ NUM_SHADES ] != qApp->palette().active().highlight() )
shadeColors( qApp->palette().active().highlight(), menuPbar );
} else
if ( qApp->palette().active().highlight() != menuPbar[ GRADIENT_BASE ] )
shadeGradient( qApp->palette().active().highlight(), menuPbar );
const QColorGroup &actGroup = pal.active(),
&inactGroup = pal.inactive();
const QColor *use = backgroundColors( actGroup );
QColorGroup newAct( actGroup.foreground(), actGroup.button(),
use[ 0 ], use[ 5 ], actGroup.mid(), actGroup.text(),
actGroup.brightText(), actGroup.base(), actGroup.background() );
newAct.setColor( QColorGroup::Highlight, actGroup.color( QColorGroup::Highlight ) );
pal.setActive( newAct );
use = backgroundColors( inactGroup );
QColorGroup newInact( inactGroup.foreground(), inactGroup.button(),
use[ 0 ], use[ 5 ], inactGroup.mid(), inactGroup.text(),
inactGroup.brightText(), inactGroup.base(), inactGroup.background() );
newInact.setColor( QColorGroup::Highlight, inactGroup.color( QColorGroup::Highlight ) );
pal.setInactive( newInact );
}
static const char * kdeToolbarWidget = "kde toolbar widget";
void KlearlookStyle::polish( QWidget *widget ) {
if ( ::qt_cast<QRadioButton *>( widget )
|| ::qt_cast<QCheckBox *>( widget )
|| ::qt_cast<QSpinWidget *>( widget )
|| widget->inherits( "QSplitterHandle" ) ) {
#if QT_VERSION >= 0x030200
widget->setMouseTracking( true );
#endif
widget->installEventFilter( this );
} else if ( ::qt_cast<QButton *>( widget ) || ::qt_cast<QComboBox *>( widget ) ||
widget->inherits( "QToolBarExtensionWidget" ) ) {
widget->setBackgroundMode( QWidget::PaletteBackground );
widget->installEventFilter( this );
} else if ( ::qt_cast<QMenuBar *>( widget )
|| ::qt_cast<QToolBar *>( widget )
|| ::qt_cast<QPopupMenu *>( widget ) )
widget->setBackgroundMode( QWidget::PaletteBackground );
else if ( widget->inherits( "KToolBarSeparator" ) ) {
widget->setBackgroundMode( QWidget::NoBackground );
widget->installEventFilter( this );
} else if ( ::qt_cast<QScrollBar *>( widget ) ) {
widget->setMouseTracking( true );
widget->installEventFilter( this );
widget->setBackgroundMode( QWidget::NoBackground );
} else if ( ::qt_cast<QSlider *>( widget ) || ::qt_cast<QHeader *>( widget ) ) {
widget->setMouseTracking( true );
widget->installEventFilter( this );
} else if ( 0 == qstrcmp( widget->name(), kdeToolbarWidget ) ) {
widget->installEventFilter( this );
widget->setBackgroundMode( QWidget::NoBackground ); // We paint the whole background.
}
KStyle::polish( widget );
}
void KlearlookStyle::unPolish( QWidget *widget ) {
if ( ::qt_cast<QRadioButton *>( widget ) ||
::qt_cast<QCheckBox *>( widget ) ||
::qt_cast<QSpinWidget *>( widget ) ||
widget->inherits( "QSplitterHandle" ) ) {
#if QT_VERSION >= 0x030200
widget->setMouseTracking( false );
#endif
widget->removeEventFilter( this );
} else if ( ::qt_cast<QButton *>( widget ) || ::qt_cast<QComboBox *>( widget ) ||
widget->inherits( "QToolBarExtensionWidget" ) ) {
widget->setBackgroundMode( QWidget::PaletteButton );
widget->removeEventFilter( this );
} else if ( ::qt_cast<QMenuBar *>( widget ) ||
::qt_cast<QToolBar *>( widget ) ||
::qt_cast<QPopupMenu *>( widget ) )
widget->setBackgroundMode( QWidget::PaletteBackground );
else if ( widget->inherits( "KToolBarSeparator" ) ) {
widget->setBackgroundMode( PaletteBackground );
widget->removeEventFilter( this );
} else if ( ::qt_cast<QScrollBar *>( widget ) ) {
widget->setMouseTracking( false );
widget->removeEventFilter( this );
widget->setBackgroundMode( QWidget::PaletteButton );
} else if ( ::qt_cast<QSlider *>( widget ) ||
::qt_cast<QHeader *>( widget ) ) {
widget->setMouseTracking( false );
widget->removeEventFilter( this );
} else if ( 0 == qstrcmp( widget->name(), kdeToolbarWidget ) ) {
widget->removeEventFilter( this );
widget->setBackgroundMode( PaletteBackground );
}
KStyle::unPolish( widget );
}
bool KlearlookStyle::eventFilter( QObject *object, QEvent *event ) {
if ( object->parent() && 0 == qstrcmp( object->name(), kdeToolbarWidget ) ) {
// Draw background for custom widgets in the toolbar that have specified a "kde toolbar widget" name.
if ( QEvent::Paint == event->type() ) {
QWidget * widget = static_cast<QWidget*>( object ),
*parent = static_cast<QWidget*>( object->parent() );
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
// Find the top-level toolbar of this widget, since it may be nested in other
// widgets that are on the toolbar.
int x_offset = widget->x(),
y_offset = widget->y();
while ( parent && parent->parent() && !qstrcmp( parent->name(), kdeToolbarWidget ) ) {
x_offset += parent->x();
y_offset += parent->y();
parent = static_cast<QWidget*>( parent->parent() );
}
QRect pr( parent->rect() );
bool horiz_grad = pr.width() < pr.height();
// Check if the parent is a QToolbar, and use its orientation, else guess.
QToolBar *toolbar = dynamic_cast<QToolBar*>( parent );
if ( toolbar )
horiz_grad = toolbar->orientation() == Qt::Vertical;
drawBevelGradient( parent->colorGroup().background(), true, 1, &QPainter( widget ),
QRect( x_offset, y_offset, pr.width(), pr.height() ),
horiz_grad, SHADE_BAR_LIGHT, SHADE_BAR_DARK );
#else
QPainter( widget ).fillRect( widget->rect(), parent->colorGroup().background() );
#endif
return false; // Now draw the contents
}
} else if ( object->inherits( "KToolBarSeparator" ) && QEvent::Paint == event->type() ) {
QFrame * frame = dynamic_cast<QFrame*>( object );
if ( frame && QFrame::NoFrame != frame->frameShape() ) {
QPainter painter( frame );
if ( QFrame::VLine == frame->frameShape() )
drawPrimitive( PE_DockWindowSeparator, &painter,
frame->rect(), frame->colorGroup(), Style_Horizontal );
else if ( QFrame::HLine == frame->frameShape() )
drawPrimitive( PE_DockWindowSeparator, &painter,
frame->rect(), frame->colorGroup() );
else
return false;
return true; // been drawn!
}
}
switch ( event->type() ) {
case QEvent::Enter:
if ( object->isWidgetType() ) {
hoverWidget = ( QWidget * ) object;
if ( hoverWidget && hoverWidget->isEnabled() ) {
if ( redrawHoverWidget() ) {
hoverWidget->repaint( false );
if ( APP_KICKER == themedApp )
hover = HOVER_NONE;
}
oldCursor = QCursor::pos();
} else
hoverWidget = NULL;
}
break;
case QEvent::Leave:
if ( hoverWidget && object == hoverWidget ) {
oldCursor.setX( -1 );
oldCursor.setY( -1 );
hoverWidget = NULL;
( ( QWidget * ) object ) ->repaint( false );
}
break;
case QEvent::MouseMove:
if ( hoverWidget && object->isWidgetType() ) {
if ( redrawHoverWidget() ) {
hoverWidget->repaint( false );
if ( APP_KICKER == themedApp )
hover = HOVER_NONE;
}
oldCursor = QCursor::pos();
}
break;
default:
break;
}
return KStyle::eventFilter( object, event );
}
void KlearlookStyle::drawLightBevelButton(
QPainter *p,
const QRect &r,
const QColorGroup &cg,
QStyle::SFlags flags,
bool useGrad,
ERound round,
const QColor &fill,
const QColor *custom,
bool light ) const
{
QRect br( r );
bool sunken = ( flags & ( QStyle::Style_Down | QStyle::Style_On | QStyle::Style_Sunken ) );
int dark = borderButton ? 4 : 5,
c1 = sunken ? dark : light ? 6 : 0;
p->save();
if ( !borderButton )
br.addCoords( -1, -1, 1, 1 );
if ( ( sunken && !borderButton ) || ( !sunken && flags & QStyle::Style_Raised ) ) {
p->setPen( custom ? custom[ c1 ] : gray[ c1 ] );
if ( APPEARANCE_LIGHT_GRADIENT != appearance ) {
int c2 = sunken ? 0 : dark;
p->drawLine( br.x() + 1, br.y() + 2, br.x() + 1, br.y() + br.height() - 3 ); // left
p->drawLine( br.x() + 1, br.y() + 1, br.x() + br.width() - 2, br.y() + 1 ); // top
p->setPen( custom ? custom[ c2 ] : gray[ c2 ] );
p->drawLine( br.x() + br.width() - 2, br.y() + 1,
br.x() + br.width() - 2, br.y() + br.height() - 3 ); // right
p->drawLine( br.x() + 1, br.y() + br.height() - 2,
br.x() + br.width() - 2, br.y() + br.height() - 2 ); // bottom
br.addCoords( 2, 2, -2, -2 );
} else {
p->drawLine( br.x() + 1, br.y() + 2, br.x() + 1, br.y() + br.height() - 2 ); // left
p->drawLine( br.x() + 1, br.y() + 1, br.x() + br.width() - 2, br.y() + 1 ); // top
br.addCoords( 2, 2, -1, -1 );
}
} else
br.addCoords( 1, 1, -1, -1 );
// fill
if ( useGrad && APPEARANCE_FLAT != appearance ) {
drawBevelGradient( fill.dark( 100 ), !sunken, 0, p,
QRect( br.left() - 1, br.top() - 1, br.width() + 2, br.height() + 2 ), flags & Style_Horizontal,
sunken ?
SHADE_BEVEL_BUTTON_GRAD_LIGHT( appearance ) :
SHADE_BEVEL_BUTTON_GRAD_LIGHT( appearance ),
sunken ?
SHADE_BEVEL_BUTTON_GRAD_DARK( appearance ) :
SHADE_BEVEL_BUTTON_GRAD_DARK( appearance ) );
} else
p->fillRect( br, fill );
if ( borderButton )
if ( rounded && ROUNDED_NONE != round ) {
bool wide = r.width() >= QTC_MIN_BTN_SIZE,
tall = r.height() >= QTC_MIN_BTN_SIZE;
QColor border( flags & Style_ButtonDefault && IND_FONT_COLOUR == defBtnIndicator & flags & Style_Enabled
? cg.text() : custom ? custom[ 5 ] : gray[ 5 ] );
p->setPen( border.light(80) );
switch ( round ) {
case ROUNDED_ALL:
p->drawLine( r.x() + 2, r.y(), r.x() + r.width() - 3, r.y() );
p->drawLine( r.x() + 2, r.y() + r.height() - 1, r.x() + r.width() - 3,
r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 2, r.x(), r.y() + r.height() - 3 );
p->drawLine( r.x() + r.width() - 1, r.y() + 2, r.x() + r.width() - 1,
r.y() + r.height() - 3 );
if ( tall && wide ) {
p->drawPoint( r.x() + r.width() - 2, r.y() + 1 );
p->drawPoint( r.x() + 1, r.y() + r.height() - 2 );
p->drawPoint( r.x() + r.width() - 2, r.y() + r.height() - 2 );
p->drawPoint( r.x() + 1, r.y() + 1 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !( tall && wide ) ) {
p->drawLine( r.x(), r.y() + 1, r.x() + 1, r.y() );
p->drawLine( r.x() + r.width() - 2, r.y(), r.x() + r.width() - 1, r.y() + 1 );
p->drawLine( r.x(), r.y() + r.height() - 2, r.x() + 1, r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 2, r.y() + r.height() - 1,
r.x() + r.width() - 1, r.y() + r.height() - 2 );
}
if ( !formMode ) {
if ( tall && wide )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() );
p->drawPoint( r.x() + r.width() - 1, r.y() );
p->drawPoint( r.x(), r.y() + r.height() - 1 );
p->drawPoint( r.x() + r.width() - 1, r.y() + r.height() - 1 );
}
break;
case ROUNDED_TOP:
p->drawLine( r.x() + 2, r.y(), r.x() + r.width() - 3, r.y() );
p->drawLine( r.x() + 1, r.y() + r.height() - 1,
r.x() + r.width() - 2, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 2, r.x(), r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 1, r.y() + 2,
r.x() + r.width() - 1, r.y() + r.height() - 1 );
if ( wide ) {
p->drawPoint( r.x() + r.width() - 2, r.y() + 1 );
p->drawPoint( r.x() + 1, r.y() + 1 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !wide ) {
p->drawLine( r.x(), r.y() + 1, r.x() + 1, r.y() );
p->drawLine( r.x() + r.width() - 2, r.y(), r.x() + r.width() - 1, r.y() + 1 );
}
if ( !formMode ) {
if ( wide )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() );
p->drawPoint( r.x() + r.width() - 1, r.y() );
}
break;
case ROUNDED_BOTTOM:
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() );
p->drawLine( r.x() + 2, r.y() + r.height() - 1,
r.x() + r.width() - 3, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y(), r.x(), r.y() + r.height() - 3 );
p->drawLine( r.x() + r.width() - 1, r.y(),
r.x() + r.width() - 1, r.y() + r.height() - 3 );
if ( wide ) {
p->drawPoint( r.x() + 1, r.y() + r.height() - 2 );
p->drawPoint( r.x() + r.width() - 2, r.y() + r.height() - 2 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !wide ) {
p->drawLine( r.x(), r.y() + r.height() - 2, r.x() + 1, r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 2, r.y() + r.height() - 1,
r.x() + r.width() - 1, r.y() + r.height() - 2 );
}
if ( !formMode ) {
if ( wide )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() + r.height() - 1 );
p->drawPoint( r.x() + r.width() - 1, r.y() + r.height() - 1 );
}
break;
case ROUNDED_LEFT:
p->drawLine( r.x() + 2, r.y(), r.x() + r.width() - 2, r.y() );
p->drawLine( r.x() + 2, r.y() + r.height() - 1,
r.x() + r.width() - 2, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 2, r.x(), r.y() + r.height() - 3 );
p->drawLine( r.x() + r.width() - 1, r.y(), r.x() + r.width() - 1,
r.y() + r.height() - 1 );
if ( tall ) {
p->drawPoint( r.x() + 1, r.y() + r.height() - 2 );
p->drawPoint( r.x() + 1, r.y() + 1 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !tall ) {
p->drawLine( r.x(), r.y() + 1, r.x() + 1, r.y() );
p->drawLine( r.x(), r.y() + r.height() - 2,
r.x() + 1, r.y() + r.height() - 1 );
}
if ( !formMode ) {
if ( tall )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() );
p->drawPoint( r.x(), r.y() + r.height() - 1 );
}
break;
case ROUNDED_RIGHT:
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 3, r.y() );
p->drawLine( r.x() + 1, r.y() + r.height() - 1,
r.x() + r.width() - 3, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y(), r.x(), r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 1, r.y() + 2,
r.x() + r.width() - 1, r.y() + r.height() - 3 );
if ( tall ) {
p->drawPoint( r.x() + r.width() - 2, r.y() + 1 );
p->drawPoint( r.x() + r.width() - 2, r.y() + r.height() - 2 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !tall ) {
p->drawLine( r.x() + r.width() - 2, r.y(), r.x() + r.width() - 1, r.y() + 1 );
p->drawLine( r.x() + r.width() - 2, r.y() + r.height() - 1,
r.x() + r.width() - 1, r.y() + r.height() - 2 );
}
if ( !formMode ) {
if ( tall )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x() + r.width() - 1, r.y() );
p->drawPoint( r.x() + r.width() - 1, r.y() + r.height() - 1 );
}
break;
default:
break;
}
} else {
p->setPen( flags & Style_ButtonDefault &&
IND_FONT_COLOUR == defBtnIndicator ?
cg.text() : custom ? custom[ 5 ] : gray[ 5 ] );
p->setBrush( NoBrush );
p->drawRect( r );
}
p->restore();
}
void KlearlookStyle::drawLightBevel(
QPainter *p,
const QRect &r,
const QColorGroup &cg,
QStyle::SFlags flags,
bool useGrad,
ERound round,
const QColor &fill,
const QColor *custom,
bool light ) const
{
QRect br( r );
bool sunken = ( flags & ( QStyle::Style_Down | QStyle::Style_On | QStyle::Style_Sunken ) );
int dark = borderButton ? 4 : 5, c1 = sunken ? dark : light ? 6 : 0;
p->save();
if ( !borderButton )
br.addCoords( -1, -1, 1, 1 );
if ( ( sunken && !borderButton ) || ( !sunken && flags & QStyle::Style_Raised ) ) {
p->setPen( custom ? custom[ c1 ] : gray[ c1 ] );
if ( APPEARANCE_LIGHT_GRADIENT != appearance ) {
int c2 = sunken ? 0 : dark;
p->drawLine( br.x() + 1, br.y() + 2, br.x() + 1, br.y() + br.height() - 3 ); // left
p->drawLine( br.x() + 1, br.y() + 1, br.x() + br.width() - 2, br.y() + 1 ); // top
p->setPen( custom ? custom[ c2 ] : gray[ c2 ] );
p->drawLine( br.x() + br.width() - 2, br.y() + 1,
br.x() + br.width() - 2, br.y() + br.height() - 3 ); // right
p->drawLine( br.x() + 1, br.y() + br.height() - 2,
br.x() + br.width() - 2, br.y() + br.height() - 2 ); // bottom
br.addCoords( 2, 2, -2, -2 );
} else {
p->drawLine( br.x() + 1, br.y() + 2, br.x() + 1, br.y() + br.height() - 2 ); // left
p->drawLine( br.x() + 1, br.y() + 1, br.x() + br.width() - 2, br.y() + 1 ); // top
br.addCoords( 2, 2, -1, -1 );
}
} else
br.addCoords( 1, 1, -1, -1 );
// fill
if ( useGrad && APPEARANCE_FLAT != appearance ) {
drawBevelGradient( fill, !sunken, 0, p,
QRect( br.left() - 1, br.top() - 1, br.width() + 2, br.height() + 2 ),
flags & Style_Horizontal,
sunken ?
SHADE_BEVEL_GRAD_SEL_LIGHT( appearance ) :
SHADE_BEVEL_GRAD_LIGHT( appearance ),
sunken ?
SHADE_BEVEL_GRAD_SEL_DARK( appearance ) :
SHADE_BEVEL_GRAD_DARK( appearance ) );
} else {
p->fillRect( br, fill );
}
if ( borderButton )
if ( rounded && ROUNDED_NONE != round ) {
bool wide = r.width() >= QTC_MIN_BTN_SIZE,
tall = r.height() >= QTC_MIN_BTN_SIZE;
QColor border = menuPbar[ GRADIENT_BASE ].dark( 130 );
p->setPen( border );
switch ( round ) {
case ROUNDED_ALL:
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() ); // top
p->drawLine( r.x() + 1, r.y() + r.height() - 1, r.x() + r.width() - 2, r.y() + r.height() - 1 ); // bottom
p->drawLine( r.x(),r.y() + 1, r.x(),r.y() + r.height() - 2 ); // left
p->drawLine( r.x() + r.width() - 1, r.y() + 1, r.x() + r.width() - 1, r.y() + r.height() - 2 ); // right
//p->drawLine( r.x() + 2, r.y() + r.height() - 1, r.x() + r.width() - 3, r.y() + r.height() - 1 );
//p->drawLine( r.x(), r.y() + 2, r.x(), r.y() + r.height() - 3 );
//p->drawLine( r.x() + r.width() - 1, r.y() + 2, r.x() + r.width() - 1, r.y() + r.height() - 3 );
if ( tall && wide ) {
//p->drawPoint( r.x() + r.width() - 2, r.y() + 1 );
//p->drawPoint( r.x() + 1, r.y() + r.height() - 2 );
//p->drawPoint( r.x() + r.width() - 2, r.y() + r.height() - 2 );
//p->drawPoint( r.x() + 1, r.y() + 1 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !( tall && wide ) ) {
//p->drawLine( r.x(), r.y() + 1, r.x() + 1, r.y() );
//p->drawLine( r.x() + r.width() - 2, r.y(), r.x() + r.width() - 1, r.y() + 1 );
//p->drawLine( r.x(), r.y() + r.height() - 2, r.x() + 1, r.y() + r.height() - 1 );
//p->drawLine( r.x() + r.width() - 2, r.y() + r.height() - 1, r.x() + r.width() - 1, r.y() + r.height() - 2 );
}
if ( !formMode ) {
if ( tall && wide )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
//p->drawPoint( r.x(), r.y() );
//p->drawPoint( r.x() + r.width() - 1, r.y() );
//p->drawPoint( r.x(), r.y() + r.height() - 1 );
//p->drawPoint( r.x() + r.width() - 1, r.y() + r.height() - 1 );
}
break;
case ROUNDED_TOP:
p->drawLine( r.x() + 2, r.y(), r.x() + r.width() - 3, r.y() );
p->drawLine( r.x() + 1, r.y() + r.height() - 1, r.x() + r.width() - 2, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 2, r.x(), r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 1, r.y() + 2, r.x() + r.width() - 1, r.y() + r.height() - 1 );
if ( wide ) {
p->drawPoint( r.x() + r.width() - 2, r.y() + 1 );
p->drawPoint( r.x() + 1, r.y() + 1 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !wide ) {
p->drawLine( r.x(), r.y() + 1, r.x() + 1, r.y() );
p->drawLine( r.x() + r.width() - 2, r.y(), r.x() + r.width() - 1, r.y() + 1 );
}
if ( !formMode ) {
if ( wide )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() );
p->drawPoint( r.x() + r.width() - 1, r.y() );
}
break;
case ROUNDED_BOTTOM:
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() );
p->drawLine( r.x() + 2, r.y() + r.height() - 1, r.x() + r.width() - 3, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y(), r.x(), r.y() + r.height() - 3 );
p->drawLine( r.x() + r.width() - 1, r.y(), r.x() + r.width() - 1, r.y() + r.height() - 3 );
if ( wide ) {
p->drawPoint( r.x() + 1, r.y() + r.height() - 2 );
p->drawPoint( r.x() + r.width() - 2, r.y() + r.height() - 2 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !wide ) {
p->drawLine( r.x(), r.y() + r.height() - 2, r.x() + 1, r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 2, r.y() + r.height() - 1,
r.x() + r.width() - 1, r.y() + r.height() - 2 );
}
if ( !formMode ) {
if ( wide )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() + r.height() - 1 );
p->drawPoint( r.x() + r.width() - 1, r.y() + r.height() - 1 );
}
break;
case ROUNDED_LEFT:
p->drawLine( r.x() + 2, r.y(), r.x() + r.width() - 2, r.y() );
p->drawLine( r.x() + 2, r.y() + r.height() - 1,
r.x() + r.width() - 2, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 2, r.x(), r.y() + r.height() - 3 );
p->drawLine( r.x() + r.width() - 1, r.y(), r.x() + r.width() - 1, r.y() + r.height() - 1 );
if ( tall ) {
p->drawPoint( r.x() + 1, r.y() + r.height() - 2 );
p->drawPoint( r.x() + 1, r.y() + 1 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !tall ) {
p->drawLine( r.x(), r.y() + 1, r.x() + 1, r.y() );
p->drawLine( r.x(), r.y() + r.height() - 2, r.x() + 1, r.y() + r.height() - 1 );
}
if ( !formMode ) {
if ( tall )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() );
p->drawPoint( r.x(), r.y() + r.height() - 1 );
}
break;
case ROUNDED_RIGHT:
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 3, r.y() );
p->drawLine( r.x() + 1, r.y() + r.height() - 1,
r.x() + r.width() - 3, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y(), r.x(), r.y() + r.height() - 1 );
p->drawLine( r.x() + r.width() - 1, r.y() + 2, r.x() + r.width() - 1,
r.y() + r.height() - 3 );
if ( tall ) {
p->drawPoint( r.x() + r.width() - 2, r.y() + 1 );
p->drawPoint( r.x() + r.width() - 2, r.y() + r.height() - 2 );
p->setPen( midColor( border, cg.background() ) );
}
if ( !formMode || !tall ) {
p->drawLine( r.x() + r.width() - 2, r.y(), r.x() + r.width() - 1, r.y() + 1 );
p->drawLine( r.x() + r.width() - 2, r.y() + r.height() - 1,
r.x() + r.width() - 1, r.y() + r.height() - 2 );
}
if ( !formMode ) {
if ( tall )
p->setPen( cg.background() );
else
p->setPen( midColor( custom ? custom[ 3 ] : gray[ 3 ], cg.background() ) );
p->drawPoint( r.x() + r.width() - 1, r.y() );
p->drawPoint( r.x() + r.width() - 1, r.y() + r.height() - 1 );
}
break;
default:
break;
}
} else {
p->setPen( flags & Style_ButtonDefault &&
IND_FONT_COLOUR == defBtnIndicator ? cg.text() : custom ? custom[ 5 ] : gray[ 5 ] );
p->setBrush( NoBrush );
p->drawRect( r );
}
p->restore();
}
void KlearlookStyle::drawArrow( QPainter *p, const QRect &r, const QColorGroup &cg, QStyle::SFlags flags,
QStyle::PrimitiveElement pe, bool small, bool checkActive ) const {
QPointArray a;
const QColor &col = flags & Style_Enabled
? checkActive && flags & Style_Active
? cg.highlightedText()
: cg.text()
: cg.mid();
if ( vArrow )
if ( small )
switch ( pe ) {
case QStyle::PE_ArrowUp:
a.setPoints( 7, 2, 1, 2, 0, 0, -2, -2, 0, -2, 1, -2, 0, 2, 0 );
break;
case QStyle::PE_ArrowDown:
a.setPoints( 7, 2, -1, 2, 0, 0, 2, -2, 0, -2, -1, -2, 0, 2, 0 );
break;
case QStyle::PE_ArrowRight:
a.setPoints( 7, 1, -2, 0, -2, -2, 0, 0, 2, 1, 2, 0, 2, 0, -2 );
break;
case QStyle::PE_ArrowLeft:
a.setPoints( 7, -1, -2, 0, -2, 2, 0, 0, 2, -1, 2, 0, 2, 0, -2 );
break;
default:
return ;
}
else
switch ( pe ) {
case QStyle::PE_ArrowUp:
a.setPoints( 7, 3, 1, 0, -2, -3, 1, -2, 2, -1, 1, 1, 1, 2, 2 );
break;
case QStyle::PE_ArrowDown:
a.setPoints( 7, 3, -1, 0, 2, -3, -1, -2, -2, -1, -1, 1, -1, 2, -2 );
break;
case QStyle::PE_ArrowRight:
a.setPoints( 7, -1, -3, 2, 0, -1, 3, -2, 2, -1, 1, -1, -1, -2, -2 );
break;
case QStyle::PE_ArrowLeft:
a.setPoints( 7, 1, -3, -2, 0, 1, 3, 2, 2, 1, 1, 1, -1, 2, -2 );
break;
default:
return ;
}
else
if ( small )
switch ( pe ) {
case QStyle::PE_ArrowUp:
a.setPoints( 4, 2, 0, 0, -2, -2, 0, 2, 0 );
break;
case QStyle::PE_ArrowDown:
a.setPoints( 4, 2, 0, 0, 2, -2, 0, 2, 0 );
break;
case QStyle::PE_ArrowRight:
a.setPoints( 4, 0, -2, -2, 0, 0, 2, 0, -2 );
break;
case QStyle::PE_ArrowLeft:
a.setPoints( 4, 0, -2, 2, 0, 0, 2, 0, -2 );
break;
default:
return ;
}
else
switch ( pe ) {
case QStyle::PE_ArrowUp:
a.setPoints( 4, 3, 1, 0, -2, -3, 1, 3, 1 );
break;
case QStyle::PE_ArrowDown:
a.setPoints( 4, 3, -1, 0, 2, -3, -1, 3, -1 );
break;
case QStyle::PE_ArrowRight:
a.setPoints( 4, -1, -3, 2, 0, -1, 3, -1, -3 );
break;
case QStyle::PE_ArrowLeft:
a.setPoints( 4, 1, -3, -2, 0, 1, 3, 1, -3 );
break;
default:
return ;
}
if ( a.isNull() )
return ;
p->save();
a.translate( ( r.x() + ( r.width() >> 1 ) ), ( r.y() + ( r.height() >> 1 ) ) );
p->setBrush( col );
p->setPen( col );
p->drawPolygon( a );
p->restore();
}
void KlearlookStyle::drawPrimitiveMenu( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg,
SFlags flags, const QStyleOption &data ) const {
switch ( pe ) {
case PE_CheckMark:
if ( flags & Style_On || !( flags & Style_Off ) ) // !(flags&Style_Off) is for tri-state
{
QPointArray check;
int x = r.center().x() - 3,
y = r.center().y() - 3;
check.setPoints( 6,
x, y + 2,
x + 2, y + 4,
x + 6, y,
x + 6, y + 2,
x + 2, y + 6,
x, y + 4 );
if ( flags & Style_On ) {
if ( flags & Style_Active ) {
p->setBrush( cg.highlightedText() );
p->setPen( cg.highlightedText() );
} else {
p->setBrush( cg.text() );
p->setPen( cg.text() );
}
} else {
p->setBrush( cg.text() );
p->setPen( cg.text() );
}
p->drawPolygon( check );
}
break;
default:
KStyle::drawPrimitive( pe, p, r, cg, flags, data );
}
}
void KlearlookStyle::drawPrimitive( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg,
SFlags flags, const QStyleOption &data ) const {
int x, y, w, h;
r.rect(&x, &y, &w, &h);
switch ( pe ) {
case PE_HeaderSection: {
const QColor * use = buttonColors( cg );
if ( APP_KICKER == themedApp ) {
if ( flags & Style_Down )
flags = ( ( flags | Style_Down ) ^ Style_Down ) | Style_Sunken;
flags |= Style_Enabled;
#if KDE_VERSION >= 0x30200
#if KDE_VERSION >= 0x30400
if ( HOVER_KICKER == hover && hoverWidget ) // && hoverWidget==p->device())
flags |= Style_MouseOver;
#endif
formMode = isTransKicker;
#endif
drawLightBevelButton( p, r, cg, flags | Style_Horizontal,
true, ROUNDED_ALL, getFill( flags, use ), use );
#if KDE_VERSION >= 0x30200
formMode = false;
#endif
} else {
flags = ( ( flags | Style_Sunken ) ^ Style_Sunken ) | Style_Raised;
if ( QTC_NO_SECT != hoverSect && HOVER_HEADER == hover && hoverWidget ) {
QHeader * hd = dynamic_cast<QHeader *>( hoverWidget );
if ( hd && hd->isClickEnabled( hoverSect ) && r == hd->sectionRect( hoverSect ) )
flags |= Style_MouseOver;
}
drawLightBevelButton( p, r, cg, flags | Style_Horizontal,
true, ROUNDED_NONE, getFill( flags, use ), use );
}
break;
}
case PE_HeaderArrow:
drawArrow( p, r, cg, flags, flags & Style_Up ? PE_ArrowUp : PE_ArrowDown );
break;
case PE_ButtonCommand:
case PE_ButtonBevel:
case PE_ButtonTool:
case PE_ButtonDropDown: {
const QColor *use = buttonColors( cg );
if ( !( flags & QStyle::Style_Sunken ) ) // If its not sunken, its raised-don't want flat buttons.
flags |= QStyle::Style_Raised;
drawLightBevelButton( p, r, cg, flags | Style_Horizontal, true,
r.width() < 16 || r.height() < 16
#if KDE_VERSION >= 0x30200
|| ( APP_KORN == themedApp && isTransKicker && PE_ButtonTool == pe )
#endif
? ROUNDED_NONE : ROUNDED_ALL,
getFill( flags, use ), use );
break;
}
case PE_ButtonDefault:
switch ( defBtnIndicator ) {
case IND_BORDER:
p->setBrush( NoBrush );
if ( rounded ) // borderButton) CPD Only use color[4] for rounded def buttons!
{
const QColor * use = buttonColors( cg );
p->setPen( use[ 4 ] );
int offset = r.width() >= QTC_MIN_BTN_SIZE && r.height() >= QTC_MIN_BTN_SIZE ? 4 : 3;
p->drawLine( r.x() + offset, r.y(), r.x() + r.width() - ( 1 + offset ), r.y() );
p->drawLine( r.x() + offset, r.y() + r.height() - 1,
r.x() + r.width() - ( 1 + offset ), r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + offset, r.x(), r.y() + r.height() - ( 1 + offset ) );
p->drawLine( r.x() + r.width() - 1, r.y() + offset,
r.x() + r.width() - 1, r.y() + r.height() - ( 1 + offset ) );
} else {
p->setPen( cg.text() );
p->drawRect( r );
}
break;
case IND_CORNER: {
const QColor *use = buttonColors( cg );
QPointArray points;
bool sunken = flags & Style_Down || flags & QStyle::Style_Sunken;
int offset = sunken ? 4 : 3;
points.setPoints( 3, r.x() + offset, r.y() + offset, r.x() + offset + 6, r.y() + offset,
r.x() + offset, r.y() + offset + 6 );
p->setBrush( use[ sunken ? 0 : borderButton ? 4 : 5 ] );
p->setPen( use[ sunken ? 0 : borderButton ? 4 : 5 ] );
p->drawPolygon( points );
break;
}
default:
break;
}
break;
case PE_IndicatorMask:
if ( rounded ) {
p->fillRect( r, color0 );
p->fillRect( r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2, color1 );
p->setPen( color1 );
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() );
p->drawLine( r.x() + 1, r.y() + r.height() - 1, r.x() + r.width() - 2, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 1, r.x(), r.y() + r.height() - 2 );
p->drawLine( r.x() + r.width() - 1, r.y() + 1, r.x() + r.width() - 1, r.y() + r.height() - 2 );
} else
p->fillRect( r, color1 );
break;
case PE_CheckMark:
if ( flags & Style_On || !( flags & Style_Off ) ) // !(flags&Style_Off) is for tri-state
{
QPointArray check;
int x = r.center().x() - 3,
y = r.center().y() - 3;
check.setPoints( 6,
x, y + 2,
x + 2, y + 4,
x + 6, y,
x + 6, y + 2,
x + 2, y + 6,
x, y + 4 );
p->setBrush( flags & Style_On
? flags & Style_Enabled
? flags & Style_Selected
? cg.highlightedText()
: cg.text()
: cg.mid()
: cg.light() );
p->setPen( flags & Style_Enabled
? flags & Style_Selected
? cg.highlightedText()
: cg.text()
: cg.mid() );
p->drawPolygon( check );
}
break;
case PE_CheckListController: {
QCheckListItem *item = data.checkListItem();
if ( item ) {
QListView * lv = item->listView();
int x = r.x(), y = r.y(), w = r.width(), h = r.height(), marg = lv->itemMargin();
p->setPen( QPen( flags & Style_Enabled ? cg.text()
: lv->palette().color( QPalette::Disabled, QColorGroup::Text ) ) );
if ( flags & Style_Selected && !lv->rootIsDecorated() &&
!( ( item->parent() && 1 == item->parent() ->rtti() &&
QCheckListItem::Controller == ( ( QCheckListItem* ) item->parent() ) ->type() ) )) {
p->fillRect( 0, 0, x + marg + w + 4, item->height(),
cg.brush( QColorGroup::Highlight ) );
if ( item->isEnabled() )
p->setPen( QPen( cg.highlightedText() ) );
}
if ( flags & Style_NoChange )
p->setBrush( cg.brush( QColorGroup::Button ) );
p->drawRect( x + marg + 2, y + 4 + 2, w - 7, h - 8 );
p->drawRect( x + marg, y + 4, w - 7, h - 8 );
}
break;
}
case PE_CheckListIndicator: {
QCheckListItem *item = data.checkListItem();
if ( item ) {
QListView * lv = item->listView();
p->setPen( QPen( flags & Style_Enabled ? cg.text()
: lv->palette().color( QPalette::Disabled, QColorGroup::Text ), 2 ) );
if ( flags & Style_Selected ) {
flags -= Style_Selected;
if ( !lv->rootIsDecorated() &&
!( ( item->parent() && 1 == item->parent() ->rtti() &&
QCheckListItem::Controller ==
( ( QCheckListItem* ) item->parent() ) ->type() ) ) ) {
p->fillRect( 0, 0, r.x() + lv->itemMargin() + r.width() + 4, item->height(),
cg.brush( QColorGroup::Highlight ) );
if ( item->isEnabled() ) {
p->setPen( QPen( cg.highlightedText(), 2 ) );
flags += Style_Selected;
}
}
}
if ( flags & Style_NoChange )
p->setBrush( cg.brush( QColorGroup::Button ) );
p->drawRect( r.x() + lv->itemMargin(), r.y() + 2, r.width() - 4, r.width() - 4 );
if ( flags & QStyle::Style_On || !( flags & Style_Off ) )
drawPrimitive( PE_CheckMark, p, QRect( r.x() + lv->itemMargin(),
r.y() + 2, r.width() - 4, r.width() - 4 ), cg, flags );
}
break;
}
case PE_Indicator: {
const QColor *use = buttonColors( cg );
bool on = flags & QStyle::Style_On || !( flags & Style_Off );
if ( APPEARANCE_FLAT != appearance )
drawPrimitive( PE_ButtonTool, p, r, cg, flags );
else {
p->fillRect( r.x() + 1, r.y() + 2, QTC_CHECK_SIZE - 2, QTC_CHECK_SIZE - 2,
flags & Style_Enabled ? cg.base() : cg.background() );
p->setPen( use[ 4 ] );
p->drawLine( r.x() + 1, r.y() + QTC_CHECK_SIZE - 1, r.x() + 1, r.y() + 1 );
p->drawLine( r.x() + 1, r.y() + 1, r.x() + QTC_CHECK_SIZE - 2, r.y() + 1 );
}
p->setPen( use[ 5 ] );
p->setBrush( NoBrush );
if ( rounded ) {
p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() );
p->drawLine( r.x() + 1, r.y() + r.height() - 1, r.x() + r.width() - 2, r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + 1, r.x(), r.y() + r.height() - 2 );
p->drawLine( r.x() + r.width() - 1, r.y() + 1, r.x() + r.width() - 1, r.y() + r.height() - 2 );
p->setPen( midColor( use[ 3 ], cg.background() ) );
p->drawPoint( r.x(), r.y() );
p->drawPoint( r.x(), r.y() + r.width() - 1 );
p->drawPoint( r.x() + r.height() - 1, r.y() );
p->drawPoint( r.x() + r.height() - 1, r.y() + r.width() - 1 );
} else if ( APPEARANCE_FLAT == appearance || borderButton )
p->drawRect( r.x(), r.y(), QTC_CHECK_SIZE, QTC_CHECK_SIZE );
if ( on )
drawPrimitive( PE_CheckMark, p, r, cg, flags );
break;
}
case PE_CheckListExclusiveIndicator: {
QCheckListItem *item = data.checkListItem();
if ( item ) {
const QColor & bgnd = cg.background(),
&on = flags & Style_Enabled
? cg.text()
: cg.mid();
bool set
= flags & QStyle::Style_On;
QPointArray outer,
inner,
aa;
int x = r.x(), y = r.y() + 2;
outer.setPoints( 24, x, y + 8, x, y + 4, x + 1, y + 3, x + 1, y + 2,
x + 2, y + 1, x + 3, y + 1, x + 4, y, x + 8, y,
x + 9, y + 1, x + 10, y + 1, x + 11, y + 2, x + 11, y + 3,
x + 12, y + 4, x + 12, y + 8, x + 11, y + 9, x + 11, y + 10,
x + 10, y + 11, x + 9, y + 11, x + 8, y + 12, x + 4, y + 12,
x + 3, y + 11, x + 2, y + 11, x + 1, y + 10, x + 1, y + 9 );
inner.setPoints( 20, x + 1, y + 8, x + 1, y + 4, x + 2, y + 3, x + 2, y + 2,
x + 3, y + 2, x + 4, y + 1, x + 8, y + 1, x + 9, y + 2,
x + 10, y + 2, x + 10, y + 3, x + 11, y + 4, x + 11, y + 8,
x + 10, y + 9, x + 10, y + 10, x + 9, y + 10, x + 8, y + 11,
x + 4, y + 11, x + 3, y + 10, x + 2, y + 10, x + 2, y + 9 );
aa.setPoints( 16, x + 2, y + 4, x + 4, y + 2, x + 8, y + 2, x + 10, y + 4,
x + 10, y + 8, x + 8, y + 10, x + 4, y + 10, x + 2, y + 8,
x, y + 3, x + 3, y, x + 9, y, x + 12, y + 3,
x + 12, y + 9, x + 9, y + 12, x + 3, y + 12, x, y + 9 );
p->setBrush( on );
p->drawPolyline( outer );
p->drawPolyline( inner );
p->setPen( midColor( on, bgnd, 1.5 ) );
p->drawPoints( aa );
if ( set
) {
p->setPen( midColor( on, bgnd ) );
p->drawLine( x + 5, y + 4, x + 7, y + 4 );
p->drawLine( x + 5, y + 8, x + 7, y + 8 );
p->drawLine( x + 4, y + 5, x + 4, y + 7 );
p->drawLine( x + 8, y + 5, x + 8, y + 7 );
p->setBrush( on );
p->setPen( NoPen );
p->drawRect( x + 5, y + 5, 3, 3 );
}
}
break;
}
case PE_ExclusiveIndicator:
case PE_ExclusiveIndicatorMask: {
int x = r.x(), y = r.y();
QPointArray outer;
outer.setPoints( 24, x, y + 8, x, y + 4, x + 1, y + 3, x + 1, y + 2,
x + 2, y + 1, x + 3, y + 1, x + 4, y, x + 8, y,
x + 9, y + 1, x + 10, y + 1, x + 11, y + 2, x + 11, y + 3,
x + 12, y + 4, x + 12, y + 8, x + 11, y + 9, x + 11, y + 10,
x + 10, y + 11, x + 9, y + 11, x + 8, y + 12, x + 4, y + 12,
x + 3, y + 11, x + 2, y + 11, x + 1, y + 10, x + 1, y + 9 );
if ( PE_ExclusiveIndicatorMask == pe ) {
p->fillRect( r, color0 );
p->setPen( Qt::color1 );
p->setBrush( Qt::color1 );
p->drawPolygon( outer );
} else {
QPointArray shadow;
const QColor &bgnd = flags & Style_Enabled ? cg.base() : cg.background(),
&on = flags & Style_Enabled
? flags & Style_Selected
? cg.highlightedText()
: cg.text()
: cg.mid();
QColor indBgnd = bgnd;
const QColor *use = buttonColors( cg );
QColor leftShadowColor,
rightShadowColor,
outerLeftColor,
outerRightColor;
bool set
= flags & QStyle::Style_On;
if ( APPEARANCE_FLAT != appearance && !borderButton )
shadow.setPoints( 14, x + 1, y + 10, x + 1, y + 9, x, y + 8, x, y + 4,
x + 1, y + 3, x + 1, y + 2, x + 2, y + 1, x + 3, y + 1,
x + 4, y, x + 8, y, x + 9, y + 1, x + 10, y + 1,
x + 11, y + 2, x + 11, y + 3 );
else
shadow.setPoints( 9, x + 2, y + 11, x + 2, y + 9, x + 1, y + 8, x + 1, y + 4,
x + 2, y + 3, x + 2, y + 2, x + 3, y + 2, x + 4, y + 1,
x + 8, y + 1 );
p->fillRect( r, crLabelHighlight && flags & Style_MouseOver
? cg.background().light( QTC_HIGHLIGHT_FACTOR ) : cg.background() );
if ( APPEARANCE_FLAT != appearance ) {
indBgnd = getFill( flags, use );
p->setClipRegion( QRegion( outer ) );
drawBevelGradient( indBgnd, !set, 0, p,
QRect( x + 1, y + 1, r.width() - 2, r.height() - 2 ), true,
set ? SHADE_BEVEL_GRAD_SEL_LIGHT( appearance ) : SHADE_BEVEL_GRAD_LIGHT( appearance ),
set ? SHADE_BEVEL_GRAD_SEL_DARK( appearance ) : SHADE_BEVEL_GRAD_DARK( appearance ) );
p->setClipping( false );
if ( ( !set
&& !( flags & Style_Down ) ) || !borderButton ) {
leftShadowColor = set
? !borderButton ? use[ 5 ] : use[ 4 ] : use[ 0 ];
p->setPen( leftShadowColor );
p->drawPolyline( shadow );
if ( APPEARANCE_LIGHT_GRADIENT == appearance )
rightShadowColor = indBgnd;
else {
if ( !borderButton )
shadow.setPoints( 10, x + 12, y + 4, x + 12, y + 8, x + 11, y + 9,
x + 11, y + 10, x + 10, y + 11, x + 9, y + 11,
x + 8, y + 12, x + 4, y + 12, x + 3, y + 11,
x + 2, y + 11 );
else
shadow.setPoints( 9, x + 10, y + 2, x + 10, y + 3, x + 11, y + 4,
x + 11, y + 8, x + 10, y + 9, x + 10, y + 10,
x + 9, y + 10, x + 8, y + 11, x + 4, y + 11 );
rightShadowColor = set
? use[ 0 ] : !borderButton ? use[ 5 ] : use[ 4 ];
p->setPen( rightShadowColor );
p->drawPolyline( shadow );
}
}
else
leftShadowColor = rightShadowColor = indBgnd;
} else {
rightShadowColor = bgnd;
p->setBrush( bgnd );
p->setPen( bgnd );
p->drawEllipse( x, y, QTC_RADIO_SIZE, QTC_RADIO_SIZE );
p->setPen( use[ 4 ] );
leftShadowColor = use[ 4 ];
p->drawPolyline( shadow );
}
if ( APPEARANCE_FLAT == appearance || borderButton ) {
p->setPen( use[ 5 ] );
p->drawPolyline( outer );
shade( use[ 5 ], &outerRightColor, 1.1 );
} else {
shade( leftShadowColor, &outerLeftColor, 1.1 );
shade( rightShadowColor, &outerRightColor, 1.1 );
}
if ( set
) {
p->setPen( midColor( on, indBgnd ) );
p->drawLine( x + 5, y + 4, x + 7, y + 4 );
p->drawLine( x + 5, y + 8, x + 7, y + 8 );
p->drawLine( x + 4, y + 5, x + 4, y + 7 );
p->drawLine( x + 8, y + 5, x + 8, y + 7 );
p->setBrush( on );
p->setPen( NoPen );
p->drawRect( x + 5, y + 5, 3, 3 );
}
if ( !formMode ) {
QPointArray outerAaLeft,
outerAaRight;
outerAaLeft.setPoints( 8, x, y + 3, x + 1, y + 1, x + 3, y,
x + 9, y, x + 11, y + 1, x + 12, y + 3,
x + 1, y + 11, x, y + 9 );
outerAaRight.setPoints( 4, x + 12, y + 9, x + 11, y + 11, x + 9, y + 12,
x + 3, y + 12 );
p->setPen( midColor( outerRightColor, cg.background() ) );
p->drawPoints( outerAaRight );
if ( APPEARANCE_FLAT != appearance && !borderButton )
p->setPen( midColor( outerLeftColor, cg.background() ) );
p->drawPoints( outerAaLeft );
if ( APPEARANCE_LIGHT_GRADIENT == appearance )
p->setPen( midColor( indBgnd, use[ 5 ], 1.75 ) );
else
p->setPen( midColor( use[ 5 ], indBgnd, 1.5 ) );
if ( APPEARANCE_FLAT != appearance ) {
QPointArray innerAa;
if ( !set
&& !( flags & Style_Down ) ) {
if ( borderButton ) {
innerAa.setPoints( 3, x + 1, y + 4, x + 2, y + 2, x + 4, y + 1 );
p->drawPoints( innerAa );
p->setPen( midColor( outerRightColor, cg.background() ) );
p->drawPoint( x + 2, y + 10 );
} else {
innerAa.setPoints( 4, x + 4, y + 11, x + 8, y + 11, x + 10, y + 10,
x + 11, y + 8 );
p->drawPoints( innerAa );
}
}
} else {
QPointArray innerAa;
innerAa.setPoints( 6, x + 4, y + 11, x + 8, y + 11, x + 10, y + 10,
x + 11, y + 8, x + 11, y + 4, x + 10, y + 2 );
p->drawPoints( innerAa );
}
}
}
break;
}
case PE_DockWindowSeparator: {
QPoint p1,
p2;
//const QColor *use=backgroundColors(cg);
if ( flags & Style_Horizontal ) {
int offset = r.height() > 18 ? 6 : r.height() > 12 ? 4 : r.height() > 6 ? 2 : 0;
p1 = QPoint( r.width() >> 1, 0 + offset );
p2 = QPoint( p1.x(), r.height() - offset );
} else {
int offset = r.width() > 18 ? 6 : r.width() > 12 ? 4 : r.width() > 6 ? 2 : 0;
p1 = QPoint( 0 + offset, r.height() >> 1 );
p2 = QPoint( r.width() - offset, p1.y() );
}
p->fillRect( r, cg.background() );
p->setPen( cg.background().dark( 111 ) );
p->drawLine( p1, p2 );
break;
}
case PE_Splitter: {
const QColor *use = buttonColors( cg );
if ( hoverWidget && hoverWidget == p->device() )
flags |= Style_MouseOver;
if ( borderSplitter )
drawLightBevelButton( p, r, cg, QStyle::Style_Raised, false,
ROUNDED_NONE, getFill( flags, use ), use );
else {
p->fillRect( r,
QColor( flags & Style_MouseOver ?
cg.background().light( QTC_HIGHLIGHT_FACTOR ) :
cg.background() ) );
drawLines( p, r, flags & Style_Horizontal, 70, 1, use, 0, TRUE,
APPEARANCE_LIGHT_GRADIENT == appearance );
}
break;
}
case PE_DockWindowResizeHandle:
p->fillRect( r, cg.background() );
if ( flags & Style_Horizontal ) {
p->setPen( cg.highlight().light() );
p->drawLine( r.left() + 1, r.top() + 1, r.right() - 1, r.top() + 1 );
p->setPen( cg.highlight() );
p->drawLine( r.left() + 1, r.top() + 2, r.right() - 1, r.top() + 2 );
p->setPen( cg.highlight().dark() );
p->drawLine( r.left() + 1, r.top() + 3, r.right() - 1, r.top() + 3 );
} else {
p->setPen( cg.highlight().light() );
p->drawLine( r.left() + 1, r.top() + 1, r.left() + 1, r.bottom() - 1 );
p->setPen( cg.highlight() );
p->drawLine( r.left() + 2, r.top() + 1, r.left() + 2, r.bottom() - 1 );
p->setPen( cg.highlight().dark() );
p->drawLine( r.left() + 3, r.top() + 1, r.left() + 3, r.bottom() - 1 );
}
break;
case PE_StatusBarSection: {
p->setPen( cg.background().dark(120) );
p->drawRect(x-2, y-2, r.width()+3, r.height()+3);
break;
}
case PE_PanelLineEdit: {
const QColor *use = backgroundColors( cg );
p->setPen( use[ 4 ].light(80) );
p->drawRect( r );
break;
}
case PE_PanelPopup: {
const QColor *use = backgroundColors( cg );
if ( borderFrame && ( data.isDefault() || data.lineWidth() > 1 ) ) {
p->setPen( use[ 4 ].light(70) );
p->setBrush( NoBrush );
drawPopupRect (p, r, cg);
//p->drawRect( r );
#ifdef MENU_POPUP_SHADOW
qDrawShadePanel( p, r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2,
QColorGroup( use[ 4 ], use[ NUM_SHADES ], use[ 0 ], use[ 4 ], use[ 2 ],
cg.text(), use[ NUM_SHADES ] ),
flags & Style_Sunken,
data.isDefault() ? QTC_BORDERED_FRAME_WIDTH - 1 : data.lineWidth() - 1 );
#endif
} else
qDrawShadePanel( p, r,
QColorGroup(
use[ 5 ], use[ NUM_SHADES ], use[ 0 ], use[ 5 ], use[ 2 ],
cg.text(), use[ NUM_SHADES ]
),
flags & Style_Sunken, data.isDefault() ? QTC_DEF_FRAME_WIDTH : data.lineWidth() );
break;
}
case PE_PanelTabWidget: {
const QColor *use = backgroundColors( cg );
if ( borderFrame && ( data.isDefault() || data.lineWidth() > 1 ) ) {
p->setPen( use[ 4 ] );
p->setBrush( NoBrush );
p->drawRect( r );
#ifdef MENU_POPUP_SHADOW
qDrawShadePanel( p, r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2,
QColorGroup( use[ 4 ], use[ NUM_SHADES ], use[ 0 ], use[ 4 ], use[ 2 ],
cg.text(), use[ NUM_SHADES ] ),
flags & Style_Sunken,
data.isDefault() ? QTC_BORDERED_FRAME_WIDTH - 1 : data.lineWidth() - 1 );
#endif
} else
qDrawShadePanel( p, r,
QColorGroup(
use[ 5 ], use[ NUM_SHADES ], use[ 0 ], use[ 5 ], use[ 2 ],
cg.text(), use[ NUM_SHADES ]
),
flags & Style_Sunken, data.isDefault() ? QTC_DEF_FRAME_WIDTH : data.lineWidth() );
break;
}
case PE_PanelDockWindow:
case PE_PanelMenuBar: {
const QColor *use = backgroundColors( cg );
switch ( toolbarBorders ) {
case TB_DARK:
qDrawShadePanel( p,
r.x(), r.y(), r.width(), r.height(),
QColorGroup(
use[ 5 ].dark( 120 ), use[ NUM_SHADES ], use[ 0 ],
use[ 5 ].dark( 120 ), use[ 2 ],
cg.text(), use[ NUM_SHADES ] ),
flags & Style_Sunken, 1
);
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
if ( APPEARANCE_FLAT != appearance )
drawBevelGradient( use[ NUM_SHADES ],
true, 1, p, r, true,
SHADE_BAR_LIGHT, SHADE_BAR_DARK
);
#endif
break;
case TB_LIGHT:
qDrawShadePanel( p,
r.x(), r.y(), r.width(), r.height(),
QColorGroup(
use[ 3 ], use[ NUM_SHADES ], use[ 0 ],
use[ 3 ], use[ 2 ],
cg.text(), use[ NUM_SHADES ]
),
flags & Style_Sunken, 1
);
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
if ( APPEARANCE_FLAT != appearance )
drawBevelGradient( use[ NUM_SHADES ],
true, 1, p, r, true,
SHADE_BAR_LIGHT, SHADE_BAR_DARK );
#endif
break;
case TB_NONE:
break;
} /* switch */
break;
}
case PE_ScrollBarAddLine:
case PE_ScrollBarSubLine: {
bool down = ( flags & ( QStyle::Style_Down | QStyle::Style_On | QStyle::Style_Sunken ) );
const QColor *use = buttonColors( cg );
pe = flags & Style_Horizontal
? PE_ScrollBarAddLine == pe
? PE_ArrowRight
: PE_ArrowLeft
: PE_ScrollBarAddLine == pe
? PE_ArrowDown
: PE_ArrowUp;
drawLightBevelButton( p, r, cg,
down ? flags : flags | ( ( ( flags & Style_Enabled ) ? Style_Raised : Style_Default ) ),
true,
PE_ArrowRight == pe ? ROUNDED_RIGHT :
PE_ArrowLeft == pe ? ROUNDED_LEFT :
PE_ArrowDown == pe ? ROUNDED_BOTTOM :
PE_ArrowUp == pe ? ROUNDED_TOP : ROUNDED_NONE,
getFill( flags, use ), use );
drawPrimitive( pe, p, r, cg, flags );
break;
}
case PE_ScrollBarSubPage:
case PE_ScrollBarAddPage: {
const QColor *use = backgroundColors( cg );
if ( borderButton ) {
if ( flags & Style_Horizontal ) {
p->fillRect( r.x(), r.y() + 1, r.width(), r.height() - 2, use[ 2 ] );
p->setPen( use[ 5 ] );
p->drawLine( r.left(), r.top(), r.right(), r.top() );
p->drawLine( r.left(), r.bottom(), r.right(), r.bottom() );
} else {
p->fillRect( r.x() + 1, r.y(), r.width() - 2, r.height(), use[ 2 ] );
p->setPen( use[ 5 ] );
p->drawLine( r.left(), r.top(), r.left(), r.bottom() );
p->drawLine( r.right(), r.top(), r.right(), r.bottom() );
}
} else
p->fillRect( r.x(), r.y(), r.width(), r.height(), use[ 2 ] );
break;
}
case PE_ScrollBarSlider: {
const QColor *use = buttonColors( cg );
if ( flags & Style_Down )
flags -= Style_Down;
flags |= flags & Style_Enabled ? Style_Raised : Style_Default;
drawLightBevelButton( p, r, cg, flags, true, ROUNDED_NONE, getFill( flags, use ), use );
if ( GROOVE_NONE != sliderThumbs &&
( ( flags & Style_Horizontal && r.width() >= 20 ) || r.height() >= 20 ) )
drawLines( p, r, !( flags & Style_Horizontal ), 3, 4, use, 0, GROOVE_SUNKEN == sliderThumbs,
APPEARANCE_LIGHT_GRADIENT == appearance );
break;
}
case PE_FocusRect: {
p->drawWinFocusRect( r, cg.background() );
break;
}
case PE_ArrowUp:
case PE_ArrowDown:
case PE_ArrowRight:
case PE_ArrowLeft:
drawArrow( p, r, cg, flags, pe );
break;
case PE_SpinWidgetUp:
case PE_SpinWidgetDown: {
QRect sr( r );
const QColor *use = buttonColors( cg );
drawLightBevelButton( p, sr, cg,
flags | Style_Horizontal, true, PE_SpinWidgetDown == pe ? ROUNDED_BOTTOM : ROUNDED_TOP,
getFill( flags, use ), use );
if ( vArrow ) {
if ( PE_SpinWidgetDown == pe )
sr.setY( sr.y() - 1 );
} else
sr.setY( sr.y() + ( PE_SpinWidgetDown == pe ? -2 : 1 ) );
drawArrow( p, sr, cg, flags, pe == PE_SpinWidgetUp ? PE_ArrowUp : PE_ArrowDown, true );
break;
}
default:
KStyle::drawPrimitive( pe, p, r, cg, flags, data );
}
}
void KlearlookStyle::drawKStylePrimitive( KStylePrimitive kpe, QPainter *p, const QWidget *widget, const QRect &r,
const QColorGroup &cg, SFlags flags, const QStyleOption &opt ) const {
switch ( kpe ) {
case KPE_ToolBarHandle:
case KPE_GeneralHandle:
drawLines( p, r, !( flags & Style_Horizontal ), 2,
APP_KICKER == themedApp ? 1 : KPE_ToolBarHandle == kpe ? 4 : 2, gray,
APP_KICKER == themedApp ? 1 : KPE_ToolBarHandle == kpe ? -2 : 0, GROOVE_SUNKEN == handles,
APPEARANCE_LIGHT_GRADIENT == appearance );
break;
case KPE_SliderGroove:
drawSliderGroove( p, r, flags, widget );
break;
case KPE_SliderHandle:
drawSliderHandle( p, r, cg, flags );
break;
case KPE_ListViewExpander: {
int lvSize = QTC_LV_SIZE( lvExpander );
QRect ar( r.x() + ( ( r.width() - ( lvSize + 4 ) ) >> 1 ),
r.y() + ( ( r.height() - ( lvSize + 4 ) ) >> 1 ), lvSize + 4, lvSize + 4 );
p->setPen( /*lvDark ? cg.text() : */cg.mid() );
if ( LV_LINES_NONE != lvLines ) {
int lo = rounded ? 2 : 0;
p->drawLine( ar.x() + lo, ar.y(), ( ar.x() + ar.width() - 1 ) - lo, ar.y() );
p->drawLine( ar.x() + lo, ar.y() + ar.height() - 1,
( ar.x() + ar.width() - 1 ) - lo, ar.y() + ar.height() - 1 );
p->drawLine( ar.x(), ar.y() + lo, ar.x(), ( ar.y() + ar.height() - 1 ) - lo );
p->drawLine( ar.x() + ar.width() - 1,
ar.y() + lo, ar.x() + ar.width() - 1, ( ar.y() + ar.height() - 1 ) - lo );
if ( rounded ) {
p->drawPoint( ar.x() + 1, ar.y() + 1 );
p->drawPoint( ar.x() + 1, ar.y() + ar.height() - 2 );
p->drawPoint( ar.x() + ar.width() - 2, ar.y() + 1 );
p->drawPoint( ar.x() + ar.width() - 2, ar.y() + ar.height() - 2 );
p->setPen( midColor( /*lvDark ? cg.text() : */cg.mid(), cg.background() ) );
p->drawLine( ar.x(), ar.y() + 1, ar.x() + 1, ar.y() );
p->drawLine( ar.x() + ar.width() - 2, ar.y(), ar.x() + ar.width() - 1, ar.y() + 1 );
p->drawLine( ar.x(), ar.y() + ar.height() - 2, ar.x() + 1, ar.y() + ar.height() - 1 );
p->drawLine( ar.x() + ar.width() - 2, ar.y() + ar.height() - 1,
ar.x() + ar.width() - 1, ar.y() + ar.height() - 2 );
}
}
if ( LV_EXP_ARR == lvExpander )
drawArrow( p, ar, cg, flags | Style_Enabled, flags & Style_On // Collapsed = On
? QApplication::reverseLayout()
? PE_ArrowLeft
: PE_ArrowRight
: PE_ArrowDown );
else {
int xo = ( ar.width() - lvSize ) >> 1,
yo = ( ar.height() - lvSize ) >> 1;
int mid = lvSize >> 1;
p->setPen( cg.text() );
p->drawLine( ar.x() + xo + ( mid - 2 ), ar.y() + yo + mid,
ar.x() + xo + lvSize - ( mid - 1 ), ar.y() + yo + mid );
if ( flags & Style_On ) // Collapsed = On
p->drawLine( ar.x() + xo + mid, ar.y() + yo + ( mid - 2 ),
ar.x() + xo + mid, ar.y() + yo + lvSize - ( mid - 1 ) );
}
break;
}
case KPE_ListViewBranch:
switch ( lvLines ) {
case LV_LINES_NONE:
break;
case LV_LINES_DOTTED:
// Taken and modified (colour wise) from kstyle.cpp - which in turn comes from
// qwindowsstyl.cpp
{
static QBitmap *verticalLine = 0,
*horizontalLine = 0;
static QCleanupHandler<QBitmap> lvCleanupBitmap;
// Create the dotline pixmaps if not already created
if ( !verticalLine ) {
// make 128*1 and 1*128 bitmaps that can be used for drawing the right sort of lines.
verticalLine = new QBitmap( 1, 129, true );
horizontalLine = new QBitmap( 128, 1, true );
QPointArray a( 64 );
QPainter p2;
p2.begin( verticalLine );
int i;
for ( i = 0; i < 64; i++ )
a.setPoint( i, 0, i * 2 + 1 );
p2.setPen( color1 );
p2.drawPoints( a );
p2.end();
QApplication::flushX();
verticalLine->setMask( *verticalLine );
p2.begin( horizontalLine );
for ( i = 0; i < 64; i++ )
a.setPoint( i, i * 2 + 1, 0 );
p2.setPen( color1 );
p2.drawPoints( a );
p2.end();
QApplication::flushX();
horizontalLine->setMask( *horizontalLine );
lvCleanupBitmap.add( &verticalLine );
lvCleanupBitmap.add( &horizontalLine );
}
p->setPen( lvDark ? cg.text() : cg.mid() ); // Wow, my big modification...
if ( flags & Style_Horizontal ) {
int point = r.x(),
other = r.y(),
end = r.x() + r.width(),
thickness = r.height();
while ( point < end ) {
int i = 128;
if ( i + point > end )
i = end - point;
p->drawPixmap( point, other, *horizontalLine, 0, 0, i, thickness );
point += i;
}
} else {
int point = r.y(),
other = r.x(),
end = r.y() + r.height(),
thickness = r.width(),
pixmapoffset = ( flags & Style_NoChange ) ? 0 : 1; // ### Hackish
while ( point < end ) {
int i = 128;
if ( i + point > end )
i = end - point;
p->drawPixmap( other, point, *verticalLine, 0, pixmapoffset, thickness, i );
point += i;
}
}
break;
}
case LV_LINES_SOLID:
p->setPen( cg.mid() );
p->drawLine( r.x(), r.y(), r.x() + r.width() - 1, r.y() + r.height() - 1 );
break;
}
break;
default:
KStyle::drawKStylePrimitive( kpe, p, widget, r, cg, flags, opt );
}
}
void KlearlookStyle::drawControl(
ControlElement control,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg, SFlags flags, const QStyleOption &data ) const
{
if ( widget == hoverWidget )
flags |= Style_MouseOver;
switch ( control ) {
case CE_TabBarTab: {
const QTabBar * tb = ( const QTabBar * ) widget;
bool cornerWidget = false,
firstTab = 0 == tb->indexOf( data.tab() ->identifier() );
if ( ::qt_cast<const QTabWidget *>( tb->parent() ) ) {
const QTabWidget * tw = ( const QTabWidget* ) tb->parent();
// is there a corner widget in the (top) left edge?
if ( tw->cornerWidget( Qt::TopLeft ) )
cornerWidget = true;
}
if ( borderFrame ) {
QRect tr( r ),
fr( r );
int offset = rounded ? 2 : 0;
switch ( tb->shape() ) {
case QTabBar::TriangularAbove:
case QTabBar::RoundedAbove:
if ( flags & Style_Selected ) {
tr.addCoords( 0, 0, 0, -1 );
fr.addCoords( 2, 2, -2, -2 );
p->setPen( gray[ 5 ] );
p->drawLine( tr.left(),
firstTab && !cornerWidget ?
tr.bottom() + 1 : tr.bottom(), tr.left(),
tr.top() + offset );
p->drawLine( tr.left() + offset, tr.top(), tr.right() - offset, tr.top() );
p->drawLine( tr.right(), tr.top() + 1, tr.right(), tr.bottom() );
p->setPen( gray[ 0 ] );
p->drawLine( tr.left() + 1, tr.bottom() + 1, tr.left() + 1, tr.top() + 2 );
p->drawLine( tr.left() + 1, tr.top() + 1, tr.right() - 1, tr.top() + 1 );
p->drawLine( tr.right() - 1, tr.bottom() + 1, tr.right(), tr.bottom() + 1 );
if ( cornerWidget )
p->drawPoint( tr.left(), tr.bottom() + 1 );
p->setPen( gray[ 4 ] );
p->drawLine( tr.right() - 1, tr.top() + 1, tr.right() - 1, tr.bottom() );
if ( rounded ) {
p->setPen( gray[ 5 ] );
p->drawPoint( tr.x() + 1, tr.y() + 1 );
p->drawPoint( tr.x() + tr.width() - 2, tr.y() + 1 );
p->setPen( gray[ 4 ] );
p->drawLine( tr.x(), tr.y() + 1, tr.x() + 1, tr.y() );
p->drawLine( tr.x() + tr.width() - 2,
tr.y(), tr.x() + tr.width() - 1, tr.y() + 1 );
}
} else {
tr.addCoords( 0, 2, 0, -1 );
fr.addCoords( 2, 4, -2, -2 );
p->setPen( gray[ 5 ] );
p->drawLine( tr.left(),
firstTab && !cornerWidget ? tr.bottom() + 1 : tr.bottom(), tr.left(),
tr.top() + 1 );
p->drawLine( rounded ? tr.left() + 1 : tr.left(),
tr.top(), rounded ? tr.right() - 1 : tr.right(), tr.top() );
p->drawLine( tr.right(), tr.top() + 1, tr.right(), tr.bottom() );
p->drawLine( tr.left(), tr.bottom(), tr.right(), tr.bottom() );
p->setPen( gray[ 0 ] );
p->drawLine( tr.left() + 1, tr.top() + 1, tr.right() - 1, tr.top() + 1 );
if ( cornerWidget )
p->drawPoint( tr.left(), tr.bottom() + 1 );
if ( !firstTab )
p->setPen( gray[ 2 ] );
p->drawLine( tr.left() + 1, tr.bottom() - 1, tr.left() + 1, tr.top() + 2 );
p->setPen( gray[ 0 ] );
p->drawLine( tr.left() + 1, tr.bottom() + 1, tr.right(), tr.bottom() + 1 );
p->setPen( gray[ 4 ] );
p->drawLine( tr.right() - 1, tr.top() + 1, tr.right() - 1, tr.bottom() - 1 );
}
if ( APPEARANCE_FLAT != appearance ) {
if ( flags & Style_Selected ) {
drawBevelGradient( cg.background(), true, 0, p, fr, true,
SHADE_TAB_SEL_LIGHT( appearance ),
SHADE_TAB_SEL_DARK( appearance ) );
p->setPen(menuPbar[ GRADIENT_BASE ]);
p->drawLine( fr.left()-1, fr.top()-1, fr.right()+1, fr.top()-1);
p->drawLine( fr.left()-1, fr.top(), fr.right()+1, fr.top());
p->setPen(menuPbar[ GRADIENT_DARK ].dark(118));
p->drawLine( fr.left(), fr.top()-2, fr.right(), fr.top()-2);
p->drawPoint( tr.x() + 1, tr.y() + 1 );
p->drawPoint( tr.x(), tr.y() + 2 );
p->drawPoint( tr.x() + tr.width() - 2, tr.y() + 1 );
p->drawPoint( tr.x() + tr.width() - 1, tr.y() + 2 );
} else
drawBevelGradient( gray[ 2 ], true, 0, p, fr, true,
SHADE_TAB_LIGHT( appearance ), SHADE_TAB_DARK( appearance ) );
} else
p->fillRect( fr, flags & Style_Selected ? cg.background() : gray[ 2 ] );
break;
case QTabBar::TriangularBelow:
case QTabBar::RoundedBelow:
if ( flags & Style_Selected ) {
fr.addCoords( 3, 2, -3, -3 );
p->setPen( gray[ 5 ] );
p->drawLine( tr.left(), tr.bottom() - offset, tr.left(),
firstTab && !cornerWidget ? tr.top() : tr.top() + 1 );
p->drawLine( rounded ? tr.left() + 1 : tr.left(),
tr.bottom(), tr.right() - offset, tr.bottom() );
p->drawLine( tr.right(), tr.top() + 1, tr.right(), tr.bottom() - 1 );
p->setPen( gray[ 0 ] );
p->drawLine( tr.left() + 1, tr.bottom() - 2, tr.left() + 1,
firstTab && !cornerWidget ? tr.top() : tr.top() - 1 );
p->setPen( gray[ 4 ] );
p->drawLine( tr.left() + 1, tr.bottom() - 1, tr.right() - 1, tr.bottom() - 1 );
p->drawLine( tr.right() - 1, tr.bottom() - 2, tr.right() - 1, tr.top() - 1 );
p->drawPoint( tr.right(), tr.top() );
if ( cornerWidget )
p->drawPoint( tr.left(), tr.top() );
if ( rounded ) {
p->setPen( gray[ 5 ] );
p->drawPoint( tr.x() + 1, tr.y() + tr.height() - 2 );
p->drawPoint( tr.x() + tr.width() - 2, tr.y() + tr.height() - 2 );
p->setPen( gray[ 4 ] );
p->drawLine( tr.x(), tr.y() + tr.height() - 2,
tr.x() + 1, tr.y() + tr.height() - 1 );
p->drawLine( tr.x() + tr.width() - 2,
tr.y() + tr.height() - 1, tr.x() + tr.width() - 1,
tr.y() + tr.height() - 2 );
}
} else {
tr.addCoords( 0, 1, 0, -2 );
fr.addCoords( 1, 2, -2, -4 );
p->setPen( gray[ 5 ] );
p->drawLine( tr.left(), tr.bottom() - 1, tr.left(),
firstTab && !cornerWidget ? tr.top() : tr.top() + 1 );
p->drawLine( rounded ? tr.left() + 1 : tr.left(), tr.bottom(),
rounded ? tr.right() - 1 : tr.right(), tr.bottom() );
p->drawLine( tr.right(), tr.top() + 1, tr.right(), tr.bottom() - 1 );
p->drawLine( tr.right(), tr.top(), tr.left(), tr.top() );
p->setPen( gray[ 4 ] );
p->drawLine( tr.left(), tr.top() - 1, tr.right(), tr.top() - 1 );
p->drawLine( tr.left() + 1, tr.bottom() - 1, tr.right() - 1, tr.bottom() - 1 );
p->drawLine( tr.right() - 1, tr.bottom() - 2, tr.right() - 1, tr.top() + 1 );
}
if ( APPEARANCE_FLAT != appearance )
if ( flags & Style_Selected )
drawBevelGradient( cg.background(), false, -1, p, fr, true,
SHADE_BOTTOM_TAB_SEL_DARK( appearance ),
SHADE_BOTTOM_TAB_SEL_LIGHT( appearance ) );
else
drawBevelGradient( gray[ 2 ], false, 0, p, fr, true,
SHADE_BOTTOM_TAB_DARK( appearance ),
SHADE_BOTTOM_TAB_LIGHT( appearance ) );
else
p->fillRect( fr, flags & Style_Selected ? cg.background() : gray[ 2 ] );
break;
default:
KStyle::drawControl( control, p, widget, r, cg, flags, data );
}
} else {
QRect br( r );
switch ( tb->shape() ) {
case QTabBar::TriangularAbove:
case QTabBar::RoundedAbove:
if ( flags & Style_Selected ) {
p->setPen( cg.background() );
p->drawLine( br.bottomLeft(), br.bottomRight() );
p->setPen( gray[ 0 ] );
p->drawPoint( br.bottomLeft() );
p->setPen( gray[ 5 ] );
p->drawPoint( br.bottomRight() );
br.addCoords( 0, 0, 0, -1 );
} else {
p->setPen( gray[ 0 ] );
p->drawLine( br.left(), br.bottom(), br.right(), br.bottom() );
br.addCoords( 0, 1, -1, -1 );
}
p->setPen( gray[ 0 == r.left() || flags & Style_Selected ? 0 : 5 ] );
p->drawLine( br.bottomLeft(), br.topLeft() );
p->setPen( gray[ 0 ] );
p->drawLine( br.left() + 1, br.top(), br.right() - 1, br.top() );
p->setPen( gray[ 5 ] );
p->drawLine( br.right(), br.top(), br.right(), br.bottom() );
br.addCoords( 1, 1, -1, 0 );
if ( APPEARANCE_FLAT != appearance )
if ( flags & Style_Selected )
drawBevelGradient( cg.background(), true, 0, p, br,
true, SHADE_TAB_SEL_LIGHT( appearance ),
SHADE_TAB_SEL_DARK( appearance ) );
else
drawBevelGradient( gray[ 2 ], true, 0, p, br, true,
SHADE_TAB_LIGHT( appearance ), SHADE_TAB_DARK( appearance ) );
else
p->fillRect( br, flags & Style_Selected ? cg.background() : gray[ 2 ] );
break;
case QTabBar::TriangularBelow:
case QTabBar::RoundedBelow:
if ( flags & Style_Selected ) {
p->setPen( cg.background() );
p->drawLine( br.topLeft(), br.topRight() );
p->setPen( gray[ 0 ] );
p->drawPoint( br.topLeft() );
p->setPen( gray[ 5 ] );
p->drawPoint( br.topRight() );
br.addCoords( 0, 1, 0, 0 );
} else {
p->setPen( gray[ 5 ] );
p->drawLine( br.left(), br.top(),
br.right(), br.top() );
br.addCoords( 0, 1, -1, -1 );
}
if ( 0 == r.left() || flags & Style_Selected ) {
p->setPen( gray[ 0 ] );
p->drawLine( br.bottomLeft(), br.topLeft() );
}
p->setPen( gray[ 5 ] );
p->drawLine( br.bottomLeft(), br.bottomRight() );
p->drawLine( br.right(), br.top(), br.right(), br.bottom() );
br.addCoords( 1, 0, -1, -1 );
if ( APPEARANCE_FLAT != appearance )
if ( flags & Style_Selected )
drawBevelGradient(
cg.background(), false, 0, p, br, true,
SHADE_BOTTOM_TAB_SEL_DARK( appearance ),
SHADE_BOTTOM_TAB_SEL_LIGHT( appearance ) );
else
drawBevelGradient( gray[ 2 ], false, 0, p, br,
true, SHADE_BOTTOM_TAB_DARK( appearance ),
SHADE_BOTTOM_TAB_LIGHT( appearance ) );
else
p->fillRect( br, flags & Style_Selected ? cg.background() : gray[ 2 ] );
}
}
break;
}
#if QT_VERSION >= 0x030200
case CE_TabBarLabel: {
if ( data.isDefault() )
break;
const QTabBar *tb = ( const QTabBar * ) widget;
QTab *t = data.tab();
QRect tr = r;
if ( t->identifier() == tb->currentTab() ) {
if ( QTabBar::RoundedAbove == tb->shape() || QTabBar::TriangularAbove == tb->shape() )
tr.setBottom( tr.bottom() - pixelMetric( QStyle::PM_TabBarTabShiftVertical, tb ) );
} else
if ( QTabBar::RoundedBelow == tb->shape() || QTabBar::TriangularBelow == tb->shape() )
tr.setTop( tr.top() + pixelMetric( QStyle::PM_TabBarTabShiftVertical, tb ) );
drawItem( p, tr, AlignCenter | ShowPrefix, cg, flags & Style_Enabled, 0, t->text() );
if ( ( flags & Style_HasFocus ) && !t->text().isEmpty() )
drawPrimitive( PE_FocusRect, p, r, cg );
break;
}
#endif
case CE_PushButtonLabel: // Taken from Highcolour and Plastik...
{
int x, y, w, h;
r.rect( &x, &y, &w, &h );
const QPushButton *button = static_cast<const QPushButton *>( widget );
bool active = button->isOn() || button->isDown(),
cornArrow = false;
// Shift button contents if pushed.
if ( active ) {
x += pixelMetric( PM_ButtonShiftHorizontal, widget );
y += pixelMetric( PM_ButtonShiftVertical, widget );
flags |= Style_Sunken;
}
// Does the button have a popup menu?
if ( button->isMenuButton() ) {
int dx = pixelMetric( PM_MenuButtonIndicator, widget ),
margin = pixelMetric( PM_ButtonMargin, widget );
if ( button->iconSet() && !button->iconSet() ->isNull() &&
( dx + button->iconSet() ->pixmap ( QIconSet::Small, QIconSet::Normal,
QIconSet::Off ).width() ) >= w )
cornArrow = true; //To little room. Draw the arrow in the corner, don't adjust the widget
else {
drawPrimitive( PE_ArrowDown,
p, visualRect( QRect(
( x + w ) - ( dx + margin ), y, dx,
h ), r ), cg, flags, data );
w -= dx;
}
}
// Draw the icon if there is one
if ( button->iconSet() && !button->iconSet() ->isNull() ) {
QIconSet::Mode mode = QIconSet::Disabled;
QIconSet::State state = QIconSet::Off;
if ( button->isEnabled() )
mode = button->hasFocus() ? QIconSet::Active : QIconSet::Normal;
if ( button->isToggleButton() && button->isOn() )
state = QIconSet::On;
QPixmap pixmap = button->iconSet() ->pixmap( QIconSet::Small, mode, state );
static const int constSpace = 2;
int xo = 0,
pw = pixmap.width(),
iw = 0;
if ( button->text().isEmpty() && !button->pixmap() )
p->drawPixmap( x + ( w >> 1 ) - ( pixmap.width() >> 1 ),
y + ( h >> 1 ) - ( pixmap.height() >> 1 ),
pixmap );
else {
iw = button->pixmap() ? button->pixmap() ->width()
: widget->fontMetrics().size( Qt::ShowPrefix, button->text() ).width();
int cw = iw + pw + constSpace;
xo = cw < w ? ( w - cw ) >> 1 : constSpace;
p->drawPixmap( x + xo, y + ( h >> 1 ) - ( pixmap.height() >> 1 ), pixmap );
xo += pw;
}
if ( cornArrow ) //Draw over the icon
drawPrimitive( PE_ArrowDown, p, visualRect( QRect( x + w - 6, x + h - 6, 7, 7 ), r ),
cg, flags, data );
if ( xo && iw ) {
x += xo + constSpace;
w = iw;
} else {
x += pw + constSpace;
w -= pw + constSpace;
}
}
// Make the label indicate if the button is a default button or not
int i,
j = boldDefText && button->isDefault() ? 2 : 1;
for ( i = 0; i < j; i++ )
drawItem( p, QRect( x + i, y, w, h ),
AlignCenter | ShowPrefix,
button->colorGroup(),
button->isEnabled(),
button->pixmap(),
button->text(), -1,
&button->colorGroup().buttonText() );
//Draw a focus rect if the button has focus
if ( flags & Style_HasFocus )
drawPrimitive( PE_FocusRect, p,
QStyle::visualRect( subRect( SR_PushButtonFocusRect, widget ), widget ), cg, flags );
break;
}
case CE_PopupMenuItem: {
if ( !widget || data.isDefault() )
break;
const QPopupMenu *popupmenu = ( const QPopupMenu * ) widget;
QMenuItem *mi = data.menuItem();
int tab = data.tabWidth(),
maxpmw = data.maxIconWidth(),
x, y, w, h;
r.rect( &x, &y, &w, &h );
if ( ( flags & Style_Active ) && ( flags & Style_Enabled ) ) {
drawPBarOrMenu( p, r, true, cg, true );
} else if ( widget->erasePixmap() && !widget->erasePixmap() ->isNull() )
p->drawPixmap( x, y, *widget->erasePixmap(), x, y, w, h );
else {
// lighter background in popup menu
p->fillRect( r, cg.background().light( 100 + popupmenuHighlightLevel ) );
}
if ( !mi )
break;
if ( mi->isSeparator() ) {
const QColor * use = backgroundColors( cg );
p->setPen( cg.background().dark(105) );
p->drawLine( r.left() + 5, r.top() + 3, r.right() - 5, r.top() + 3 );
break;
}
maxpmw = QMAX( maxpmw, 16 );
QRect cr, ir, tr, sr;
if (menuIcons) {
// check column
cr.setRect( r.left(), r.top(), maxpmw, r.height() );
// submenu indicator column
sr.setCoords( r.right() - maxpmw, r.top(), r.right(), r.bottom() );
// tab/accelerator column
tr.setCoords( sr.left() - tab - 4, r.top(), sr.left(), r.bottom() );
// item column
ir.setCoords( cr.right() + 2, r.top(), tr.right() - 4, r.bottom() );
} else {
// item column
ir.setCoords( r.left() + 4, r.top(), r.width() , r.bottom() );
// check column
cr.setCoords( r.right() - maxpmw, r.top(), r.right(), r.bottom() );
// submenu indicator column
sr.setCoords( r.right() - maxpmw, r.top(), r.right(), r.bottom() );
// tab/accelerator column
tr.setCoords( sr.left() - tab - 4, r.top(), sr.left(), r.bottom() );
}
bool reverse = QApplication::reverseLayout();
if ( reverse ) {
cr = visualRect( cr, r );
sr = visualRect( sr, r );
tr = visualRect( tr, r );
ir = visualRect( ir, r );
}
if ( mi->iconSet() && menuIcons ) {
// Select the correct icon from the iconset
QIconSet::Mode mode = flags & Style_Active
? ( mi->isEnabled() ? QIconSet::Active : QIconSet::Disabled )
: ( mi->isEnabled() ? QIconSet::Normal : QIconSet::Disabled );
cr = visualRect( QRect( x, y, maxpmw, h ), r );
// Do we have an icon and are checked at the same time?
// Then draw a "pressed" background behind the icon
if ( popupmenu->isCheckable() && mi->isChecked() ) {
QBrush brush( gray[ 3 ] );
qDrawShadePanel( p,
cr.x() + 1, cr.y() + 2, cr.width() - 2, cr.height() - 4,
QColorGroup( gray[ 5 ], gray[ NUM_SHADES ], gray[ 0 ], gray[ 5 ],
gray[ 2 ], cg.text(), gray[ NUM_SHADES ] ),
true, 1, &brush );
}
// Draw the icon
QPixmap pixmap = mi->iconSet() ->pixmap( QIconSet::Small, mode );
QRect pmr( 0, 0, pixmap.width(), pixmap.height() );
pmr.moveCenter( cr.center() );
p->drawPixmap( pmr.topLeft(), pixmap );
} else if ( popupmenu->isCheckable() && mi->isChecked() ) {
// check column
cr.setRect( r.left(), r.top(), maxpmw, r.height() );
// submenu indicator column
sr.setCoords( r.right() - maxpmw, r.top(), r.right(), r.bottom() );
// tab/accelerator column
tr.setCoords( sr.left() - tab - 4, r.top(), sr.left(), r.bottom() );
// item column
ir.setCoords( cr.right() + 2, r.top(), tr.right() - 4, r.bottom() );
QBrush brush( mi->isEnabled() ? cg.highlightedText() : cg.background() );
drawPrimitiveMenu( PE_CheckMark, p, cr, cg,
( flags & ( Style_Enabled | Style_Active ) ) | Style_On );
}
QColor textcolor, embosscolor;
if ( flags & Style_Active ) {
if ( !( flags & Style_Enabled ) ) {
textcolor = cg.text();
embosscolor = cg.light();
} else {
textcolor = cg.highlightedText();
embosscolor = cg.midlight().light();
}
} else if ( !( flags & Style_Enabled ) ) {
textcolor = cg.text();
embosscolor = cg.light();
} else
textcolor = embosscolor = cg.buttonText();
p->setPen( textcolor );
if ( mi->custom() ) {
p->save();
if ( !( flags & Style_Enabled ) ) {
p->setPen( cg.light() );
mi->custom() ->paint( p, cg, ( flags & Style_Enabled ) ? ( flags & Style_Active ) : 0,
flags & Style_Enabled, ir.x() + 1, ir.y() + 1, ir.width() - 1,
ir.height() - 1 );
p->setPen( textcolor );
}
mi->custom() ->paint( p, cg, ( flags & Style_Enabled ) ? ( flags & Style_Active ) : 0,
flags & Style_Enabled, ir.x(), ir.y(), ir.width(), ir.height() );
p->restore();
}
QString text = mi->text();
if ( !text.isNull() ) {
int t = text.find( '\t' );
// draw accelerator/tab-text
if ( t >= 0 ) {
int alignFlag = AlignVCenter | ShowPrefix | DontClip | SingleLine;
alignFlag |= ( reverse ? AlignLeft : AlignRight );
if ( !( flags & Style_Enabled ) ) {
p->setPen( embosscolor );
tr.moveBy( 1, 1 );
p->drawText( tr, alignFlag, text.mid( t + 1 ) );
tr.moveBy( -1, -1 );
p->setPen( textcolor );
}
p->drawText( tr, alignFlag, text.mid( t + 1 ) );
}
int alignFlag = AlignVCenter | ShowPrefix | DontClip | SingleLine;
alignFlag |= ( reverse ? AlignRight : AlignLeft );
if ( !( flags & Style_Enabled ) ) {
p->setPen( embosscolor );
ir.moveBy( 1, 1 );
p->drawText( ir, alignFlag, text, t );
ir.moveBy( -1, -1 );
p->setPen( textcolor );
}
p->drawText( ir, alignFlag, text, t );
} else if ( mi->pixmap() ) {
QPixmap pixmap = *mi->pixmap();
if ( 1 == pixmap.depth() )
p->setBackgroundMode( OpaqueMode );
p->drawPixmap( ir.x(), ( ir.height() - pixmap.height() ) >> 1, pixmap );
if ( pixmap.depth() == 1 )
p->setBackgroundMode( TransparentMode );
}
if ( mi->popup() )
drawArrow( p, sr, cg, flags, reverse ? PE_ArrowLeft : PE_ArrowRight, false, true );
break;
}
case CE_MenuBarItem: {
if ( ( flags & Style_Enabled ) &&
( flags & Style_Active ) &&
( flags & Style_Down ) ) {
drawPBarOrMenu2( p, QRect(r.x(), r.y(), r.width(), r.height()),
true, cg, true );
} else
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
if ( APPEARANCE_FLAT != appearance )
drawBevelGradient( cg.background(), true, 0, p,
r,
true, SHADE_BAR_LIGHT, SHADE_BAR_DARK );
else
#endif
if (darkMenubar) {
drawBevelGradient( cg.background(), true, 1, p,
QRect(r.x()-1, r.y()-1, r.width()+2, r.height()+2),
true,
SHADE_BEVEL_MENU_GRAD_LIGHT( appearance ), SHADE_BEVEL_MENU_GRAD_DARK( appearance ));
} else
p->fillRect( r, cg.background() );
if ( data.isDefault() )
break;
QMenuItem *mi = data.menuItem();
if ( flags & Style_Active && ( flags & Style_Down ) )
drawItem( p, r, AlignCenter | ShowPrefix | DontClip | SingleLine,
cg, flags & Style_Enabled, mi->pixmap(), mi->text(), -1, &cg.highlightedText() );
else
drawItem( p, r, AlignCenter | ShowPrefix | DontClip | SingleLine, cg,
flags & Style_Enabled, mi->pixmap(), mi->text(), -1, &cg.buttonText() );
break;
}
case CE_MenuBarEmptyArea:
if (darkMenubar) {
//p->fillRect( r, cg.background().dark( 106 ) );
QColor b;
b.setRgb(cg.background().red(), cg.background().green(), cg.background().blue());
drawBevelGradient( b, true, 1, p,
QRect(r.x()-1, r.y()-1, r.width()+2, r.height()+2 ),
true,
SHADE_BEVEL_MENU_GRAD_LIGHT( appearance ), SHADE_BEVEL_MENU_GRAD_DARK( appearance ));
} else
p->fillRect( r, cg.background() );
break;
case CE_DockWindowEmptyArea:
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
if ( APPEARANCE_FLAT != appearance )
drawBevelGradient( cg.background(), true, 1, p, r, true, SHADE_BAR_LIGHT, SHADE_BAR_DARK );
else
#endif
p->fillRect( r, cg.background() );
break;
case CE_ProgressBarGroove:
p->setBrush( gray[ NUM_SHADES ] );
p->drawRect( r );
qDrawShadePanel( p, r,
QColorGroup( gray[ 5 ], gray[ NUM_SHADES ], gray[ 0 ], gray[ 5 ], gray[ 2 ],
cg.text(), gray[ NUM_SHADES ] ), true, 1 );
break;
case CE_ProgressBarContents: {
// ### Take into account totalSteps()for busy indicator
const QProgressBar *pb = ( const QProgressBar* ) widget;
QRect cr = subRect( SR_ProgressBarContents, widget );
double progress = pb->progress();
bool reverse = QApplication::reverseLayout();
int steps = pb->totalSteps();
if ( cr.isValid() && ( progress > 0 || steps == 0 ) ) {
double pg = ( steps == 0 ) ? 0.1 : progress / steps;
int width = QMIN( cr.width(), ( int ) ( pg * cr.width() ) );
if ( 0 == steps ) //Busy indicator
{
if ( width < 1 )
width = 1; //A busy indicator with width 0 is kind of useless
int remWidth = cr.width() - width; //Never disappear completely
if ( remWidth <= 0 )
remWidth = 1; //Do something non-crashy when too small...
int pstep = int( progress ) % ( 2 * remWidth );
if ( pstep > remWidth ) {
//Bounce about.. We're remWidth +some delta, we want to be remWidth-delta...
//-((remWidth +some delta)-2* remWidth)=-(some deleta-remWidth)=remWidth-some delta..
pstep = -( pstep - 2 * remWidth );
}
if ( reverse )
drawPBarOrMenu( p, QRect( cr.x() + cr.width() - width - pstep,
cr.y(), width, cr.height() ), true, cg );
else
drawPBarOrMenu( p, QRect( cr.x() + pstep, cr.y(), width,
cr.height() ), true, cg );
} else
if ( reverse )
drawPBarOrMenu( p, QRect( cr.x() + ( cr.width() - width ),
cr.y(), width, cr.height() ), true, cg );
else
drawPBarOrMenu( p, QRect( cr.x(), cr.y(), width, cr.height() ), true, cg );
}
break;
}
case CE_PushButton: {
const QPushButton *button = static_cast<const QPushButton *>( widget );
QRect br( r );
int dbi = pixelMetric( PM_ButtonDefaultIndicator, widget );
if ( rounded && isFormWidget( widget ) )
formMode = true;
if ( widget == hoverWidget )
flags |= Style_MouseOver;
if ( IND_BORDER == defBtnIndicator )
br.setCoords( br.left() + dbi, br.top() + dbi, br.right() - dbi, br.bottom() - dbi );
else if ( IND_FONT_COLOUR == defBtnIndicator && button->isDefault() )
flags |= Style_ButtonDefault;
p->save();
p->setBrushOrigin( -widget->backgroundOffset().x(), -widget->backgroundOffset().y() );
// draw button
drawPrimitive( PE_ButtonCommand, p, br, cg, flags );
if ( button->isDefault() && IND_FONT_COLOUR != defBtnIndicator )
drawPrimitive( PE_ButtonDefault, p, r, cg, flags );
p->restore();
formMode = false;
break;
}
case CE_CheckBox:
drawPrimitive( PE_Indicator, p, r, cg, flags, data );
break;
case CE_CheckBoxLabel:
if ( crLabelHighlight ) {
const QCheckBox * checkbox = ( const QCheckBox * ) widget;
if ( flags & Style_MouseOver &&
#if QT_VERSION >= 0x030200
HOVER_CHECK == hover && hoverWidget == widget &&
#endif
!isFormWidget( widget ) ) {
#if QT_VERSION >= 0x030200
QRect cr( checkbox->rect() );
QRegion r( QRect( cr.x(), cr.y(),
visualRect( subRect( SR_CheckBoxFocusRect, widget ), widget ).width() +
pixelMetric( PM_IndicatorWidth ) + 4, cr.height() ) );
#else
QRegion r( checkbox->rect() );
#endif
r -= visualRect( subRect( SR_CheckBoxIndicator, widget ), widget );
p->setClipRegion( r );
p->fillRect( checkbox->rect(), cg.background().light( QTC_HIGHLIGHT_FACTOR ) );
p->setClipping( false );
}
int alignment = QApplication::reverseLayout() ? AlignRight : AlignLeft;
drawItem( p, r, alignment | AlignVCenter | ShowPrefix, cg,
flags & Style_Enabled, checkbox->pixmap(), checkbox->text() );
if ( checkbox->hasFocus() )
drawPrimitive( PE_FocusRect, p,
visualRect( subRect( SR_CheckBoxFocusRect, widget ), widget ), cg, flags );
} else
KStyle::drawControl( control, p, widget, r, cg, flags, data );
break;
case CE_RadioButton:
formMode = isFormWidget( widget );
drawPrimitive( PE_ExclusiveIndicator, p, r, cg, flags, data );
formMode = false;
break;
case CE_RadioButtonLabel:
if ( crLabelHighlight ) {
const QRadioButton * radiobutton = ( const QRadioButton * ) widget;
if ( flags & Style_MouseOver &&
#if QT_VERSION >= 0x030200
HOVER_RADIO == hover && hoverWidget == widget &&
#endif
!isFormWidget( widget ) ) {
#if QT_VERSION >= 0x030200
QRect rb( radiobutton->rect() );
QRegion r( QRect( rb.x(), rb.y(),
visualRect( subRect( SR_RadioButtonFocusRect, widget ), widget ).width() +
pixelMetric( PM_ExclusiveIndicatorWidth ) + 4, rb.height() ) );
#else
QRegion r( radiobutton->rect() );
#endif
r -= visualRect( subRect( SR_RadioButtonIndicator, widget ), widget );
p->setClipRegion( r );
p->fillRect( radiobutton->rect(), cg.background().light( QTC_HIGHLIGHT_FACTOR ) );
p->setClipping( false );
}
int alignment = QApplication::reverseLayout() ? AlignRight : AlignLeft;
drawItem( p, r, alignment | AlignVCenter | ShowPrefix, cg,
flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text() );
if ( radiobutton->hasFocus() )
drawPrimitive( PE_FocusRect, p,
visualRect( subRect( SR_RadioButtonFocusRect, widget ), widget ), cg, flags );
break;
}
default:
KStyle::drawControl( control, p, widget, r, cg, flags, data );
}
}
void KlearlookStyle::drawControlMask( ControlElement control, QPainter *p, const QWidget *widget, const QRect &r,
const QStyleOption &data ) const {
switch ( control ) {
case CE_PushButton:
if ( rounded ) {
int offset = r.width() < QTC_MIN_BTN_SIZE || r.height() < QTC_MIN_BTN_SIZE ? 1 : 2;
p->fillRect( r, color0 );
p->fillRect( r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2, color1 );
p->setPen( color1 );
p->drawLine( r.x() + offset, r.y(), r.x() + r.width() - ( offset + 1 ), r.y() );
p->drawLine( r.x() + offset, r.y() + r.height() - 1,
r.x() + r.width() - ( offset + 1 ), r.y() + r.height() - 1 );
p->drawLine( r.x(), r.y() + offset, r.x(), r.y() + r.height() - ( offset + 1 ) );
p->drawLine( r.x() + r.width() - 1, r.y() + offset,
r.x() + r.width() - 1, r.y() + r.height() - ( offset + 1 ) );
} else
p->fillRect( r, color1 );
break;
default:
KStyle::drawControlMask( control, p, widget, r, data );
}
}
void KlearlookStyle::drawComplexControlMask( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r,
const QStyleOption &data ) const {
switch ( control ) {
case CC_ToolButton:
case CC_ComboBox:
drawControlMask( CE_PushButton, p, widget, r, data );
break;
default:
KStyle::drawComplexControlMask( control, p, widget, r, data );
}
}
QRect KlearlookStyle::subRect( SubRect subrect, const QWidget *widget ) const {
QRect rect,
wrect( widget->rect() );
switch ( subrect ) {
case SR_PushButtonFocusRect: {
// const QPushButton *button=(const QPushButton *)widget;
int dbw1 = 0,
dbw2 = 0;
// if(button->isDefault() || button->autoDefault())
// {
dbw1 = pixelMetric( PM_ButtonDefaultIndicator, widget );
dbw2 = dbw1 * 2;
// }
rect.setRect( wrect.x() + 3 + dbw1,
wrect.y() +3 + dbw1,
wrect.width() - 6 - dbw2,
wrect.height() - 6 - dbw2 );
break;
}
case SR_CheckBoxIndicator: {
int h = pixelMetric( PM_IndicatorHeight );
rect.setRect( ( widget->rect().height() - h ) >> 1,
( widget->rect().height() - h ) >> 1,
pixelMetric( PM_IndicatorWidth ),
h );
break;
}
case SR_RadioButtonIndicator: {
int h = pixelMetric( PM_ExclusiveIndicatorHeight );
rect.setRect( ( widget->rect().height() - h ) >> 1,
( widget->rect().height() - h ) >> 1,
pixelMetric( PM_ExclusiveIndicatorWidth ), h );
break;
}
case SR_ProgressBarContents:
rect = QRect( wrect.x() + 1,
wrect.y() + 1,
wrect.width() - 2,
wrect.height() - 2 );
break;
default:
rect = KStyle::subRect( subrect, widget );
}
return rect;
}
void KlearlookStyle::drawComplexControl(
ComplexControl control,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags flags,
SCFlags controls,
SCFlags active,
const QStyleOption &data ) const
{
if ( widget == hoverWidget )
flags |= Style_MouseOver;
switch ( control ) {
case CC_ToolButton: {
const QToolButton * toolbutton = ( const QToolButton * ) widget;
QRect button ( querySubControlMetrics( control, widget, SC_ToolButton, data ) ),
menuarea( querySubControlMetrics( control, widget, SC_ToolButtonMenu, data ) );
SFlags bflags = flags, mflags = flags;
if ( APP_KORN == themedApp ) {
drawPrimitive( PE_ButtonTool, p, button, cg, bflags, data );
break;
}
bool onControlButtons = false,
onToolbar = widget->parentWidget() && ::qt_cast<QToolBar *>( widget->parentWidget() ),
onExtender = !onToolbar &&
widget->parentWidget() &&
widget->parentWidget() ->inherits( "QToolBarExtensionWidget" ) &&
::qt_cast<QToolBar *>( widget->parentWidget() ->parentWidget() );
if ( !onToolbar && !onExtender && widget->parentWidget() &&
!qstrcmp( widget->parentWidget() ->name(), "qt_maxcontrols" ) )
onControlButtons = true;
if ( active & SC_ToolButton )
bflags |= Style_Down;
if ( active & SC_ToolButtonMenu )
mflags |= Style_Down;
if ( controls & SC_ToolButton ) {
// If we're pressed, on, or raised...
#if KDE_VERSION >= 0x30200
if ( bflags & ( Style_Down | Style_On | Style_Raised ) || onControlButtons )
#else
// CPD: Style_MouseOver obove is *needed* for KDE's KToggleActions...
if ( bflags & ( Style_Down | Style_On | Style_Raised | Style_MouseOver ) || onControlButtons )
#endif
{
//Make sure the standalone toolbuttons have a gradient in the right direction
if ( !onToolbar && !onControlButtons )
bflags |= Style_Horizontal;
drawPrimitive( PE_ButtonTool, p, button, cg, bflags, data );
}
// Check whether to draw a background pixmap
else if ( toolbutton->parentWidget() &&
toolbutton->parentWidget() ->backgroundPixmap() &&
!toolbutton->parentWidget() ->backgroundPixmap() ->isNull() ) {
p->drawTiledPixmap( r,
*( toolbutton->parentWidget() ->backgroundPixmap() ), toolbutton->pos() );
} else if ( widget->parent() ) {
if ( ::qt_cast<const QToolBar *>( widget->parent() ) ) {
QToolBar * parent = ( QToolBar* ) widget->parent();
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
if ( APPEARANCE_FLAT != appearance )
drawBevelGradient( cg.background(), true, 0,
p, parent->rect(), true, SHADE_BAR_LIGHT, SHADE_BAR_DARK );
else
#endif
p->fillRect( parent->rect(), cg.background() );
} else if ( widget->parent() ->inherits( "QToolBarExtensionWidget" ) ) {
QWidget * parent = ( QWidget* ) widget->parent();
QToolBar *toolbar = ( QToolBar* ) parent->parent();
#ifdef QTC_GRADIENT_TOOLBARS_AND_MENUBARS
if ( APPEARANCE_FLAT != appearance )
drawBevelGradient( cg.background(), true, 0, p, toolbar->rect(),
true, SHADE_BAR_LIGHT, SHADE_BAR_DARK );
else
#endif
p->fillRect( toolbar->rect(), cg.background() );
}
}
}
if ( controls & SC_ToolButtonMenu ) {
if ( mflags & ( Style_Down | Style_On | Style_Raised ) )
drawPrimitive( PE_ButtonDropDown, p, menuarea, cg, mflags, data );
drawPrimitive( PE_ArrowDown, p, menuarea, cg, mflags, data );
}
if ( toolbutton->hasFocus() && !toolbutton->focusProxy() ) {
QRect fr = toolbutton->rect();
fr.addCoords( 3, 3, -3, -3 );
drawPrimitive( PE_FocusRect, p, fr, cg );
}
break;
}
case CC_ComboBox: {
const QComboBox *combobox = ( const QComboBox * ) widget;
QRect frame( QStyle::visualRect( querySubControlMetrics( CC_ComboBox,
widget,SC_ComboBoxFrame,data ),widget ) ),
arrow( QStyle::visualRect( querySubControlMetrics( CC_ComboBox,
widget,SC_ComboBoxArrow,data),widget)),
field( QStyle::visualRect( querySubControlMetrics(CC_ComboBox,
widget,SC_ComboBoxEditField,data),widget));
const QColor *use = buttonColors( cg );
if ( rounded && isFormWidget( widget ) )
formMode = true;
if ( controls & SC_ComboBoxFrame && frame.isValid() ) {
if ( controls & SC_ComboBoxEditField && field.isValid() && combobox->editable() ) {
QRect f2( field );
QRegion reg( r );
f2.addCoords( -1, -1, 1, 1 );
reg -= f2;
p->setClipRegion( reg );
}
drawLightBevelButton( p, r, cg, flags | Style_Raised | Style_Horizontal,
true, ROUNDED_ALL, getFill( flags, use ),
use );
p->setClipping( false );
}
if ( controls & SC_ComboBoxArrow && arrow.isValid() ) {
drawPrimitive( PE_ArrowDown, p, arrow, cg, flags & ~Style_MouseOver );
p->setPen( use[ 4 ].light(70) );
arrow.addCoords( -1, -1, -1, 1 );
p->drawLine( arrow.left(), arrow.top(), arrow.left(), arrow.bottom() );
}
if ( controls & SC_ComboBoxEditField && field.isValid() ) {
if ( ( flags & Style_HasFocus ) && ( ! combobox->editable() ) ) {
QRect fr = QStyle::visualRect( subRect( SR_ComboBoxFocusRect, widget ), widget );
fr.addCoords( 0, 0, -2, 0 );
drawPrimitive( PE_FocusRect,
p, fr, cg, flags | Style_FocusAtBorder, QStyleOption( cg.highlight() ) );
}
}
p->setPen( flags & Style_Enabled ? cg.buttonText() : cg.mid() );
formMode = false;
break;
}
case CC_SpinWidget: {
const QSpinWidget *spinwidget = ( const QSpinWidget * ) widget;
QRect frame( querySubControlMetrics( CC_SpinWidget, widget, SC_SpinWidgetFrame, data ) ),
up( spinwidget->upRect() ),
down( spinwidget->downRect() );
if ( hoverWidget && spinwidget == hoverWidget )
flags |= Style_MouseOver;
if ( ( controls & SC_SpinWidgetFrame ) && frame.isValid() )
qDrawShadePanel(
p, r, QColorGroup( gray[ 5 ], gray[ NUM_SHADES ], gray[ 0 ],
gray[ 5 ], gray[ 2 ], cg.text(), gray[ NUM_SHADES ] ),
true, pixelMetric( PM_SpinBoxFrameWidth )
);
if ( ( controls & SC_SpinWidgetUp ) && up.isValid() ) {
PrimitiveElement pe = PE_SpinWidgetUp;
SFlags upflags = flags;
if ( spinwidget->buttonSymbols() == QSpinWidget::PlusMinus )
pe = PE_SpinWidgetPlus;
if ( !spinwidget->isUpEnabled() )
upflags ^= Style_Enabled;
drawPrimitive(
pe, p, up, cg,
upflags | ( ( active == SC_SpinWidgetUp ) ? Style_On | Style_Sunken : Style_Raised )
);
}
if ( ( controls & SC_SpinWidgetDown ) && down.isValid() ) {
PrimitiveElement pe = PE_SpinWidgetDown;
SFlags downflags = flags;
if ( spinwidget->buttonSymbols() == QSpinWidget::PlusMinus )
pe = PE_SpinWidgetMinus;
if ( !spinwidget->isDownEnabled() )
downflags ^= Style_Enabled;
drawPrimitive(
pe, p, down, cg,
downflags | ( ( active == SC_SpinWidgetDown ) ? Style_On | Style_Sunken : Style_Raised )
);
}
const QColor *use = backgroundColors( cg );
p->setPen( use[ 4 ].light(80) );
p->drawRect( r );
break;
}
case CC_ScrollBar: {
const QScrollBar *scrollbar = ( const QScrollBar * ) widget;
bool hw = hoverWidget == scrollbar;
QRect subline( querySubControlMetrics( control, widget, SC_ScrollBarSubLine, data ) ),
addline( querySubControlMetrics( control, widget, SC_ScrollBarAddLine, data ) ),
subpage( querySubControlMetrics( control, widget, SC_ScrollBarSubPage, data ) ),
addpage( querySubControlMetrics( control, widget, SC_ScrollBarAddPage, data ) ),
slider( querySubControlMetrics( control, widget, SC_ScrollBarSlider, data ) ),
first( querySubControlMetrics( control, widget, SC_ScrollBarFirst, data ) ),
last( querySubControlMetrics( control, widget, SC_ScrollBarLast, data ) );
if ( ( controls & SC_ScrollBarSubLine ) && subline.isValid() )
drawPrimitive(
PE_ScrollBarSubLine, p, subline, cg,
( hw && HOVER_SB_SUB == hover ? Style_MouseOver : Style_Default ) |
Style_Enabled |
( ( active == SC_ScrollBarSubLine ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default )
);
if ( ( controls & SC_ScrollBarAddLine ) && addline.isValid() )
drawPrimitive(
PE_ScrollBarAddLine, p, addline, cg,
( hw && HOVER_SB_ADD == hover ? Style_MouseOver : Style_Default ) |
Style_Enabled |
( ( active == SC_ScrollBarAddLine ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default )
);
if ( ( controls & SC_ScrollBarSubPage ) && subpage.isValid() )
drawPrimitive( PE_ScrollBarSubPage, p, subpage, cg,
Style_Enabled |
( ( active == SC_ScrollBarSubPage ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarAddPage ) && addpage.isValid() )
drawPrimitive( PE_ScrollBarAddPage, p, addpage, cg,
( ( scrollbar->minValue() == scrollbar->maxValue() ) ? Style_Default : Style_Enabled ) |
( ( active == SC_ScrollBarAddPage ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarFirst ) && first.isValid() )
drawPrimitive( PE_ScrollBarFirst, p, first, cg,
Style_Enabled |
( ( active == SC_ScrollBarFirst ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarLast ) && last.isValid() )
drawPrimitive( PE_ScrollBarLast, p, last, cg,
Style_Enabled |
( ( active == SC_ScrollBarLast ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarSlider ) && slider.isValid() ) {
drawPrimitive( PE_ScrollBarSlider, p, slider, cg,
( hw && HOVER_SB_SLIDER == hover ? Style_MouseOver : Style_Default ) |
Style_Enabled |
( ( active == SC_ScrollBarSlider ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
// ### perhaps this should not be able to accept focus if maxedOut?
if ( scrollbar->hasFocus() )
drawPrimitive( PE_FocusRect, p,
QRect( slider.x() + 2, slider.y() + 2, slider.width() - 5, slider.height() - 5 ),
cg, Style_Default );
}
break;
}
case CC_Slider: {
QRect groove = querySubControlMetrics( CC_Slider, widget, SC_SliderGroove, data ),
handle = querySubControlMetrics( CC_Slider, widget, SC_SliderHandle, data );
if ( ( controls & SC_SliderGroove ) && groove.isValid() )
drawSliderGroove( p, groove, flags, widget );
if ( ( controls & SC_SliderHandle ) && handle.isValid() )
drawSliderHandle( p, handle, cg, flags );
if ( controls & SC_SliderTickmarks )
QCommonStyle::drawComplexControl(
control, p, widget, r, cg, flags, SC_SliderTickmarks, active, data
);
break;
}
default:
KStyle::drawComplexControl( control, p, widget, r, cg, flags, controls, active, data );
}
}
QRect KlearlookStyle::querySubControlMetrics( ComplexControl control, const QWidget *widget, SubControl sc,
const QStyleOption &data ) const {
switch ( control ) {
case CC_SpinWidget: {
if ( !widget )
return QRect();
int fw = pixelMetric( PM_SpinBoxFrameWidth, 0 );
QSize bs;
bs.setHeight( widget->height() >> 1 );
if ( bs.height() < 8 )
bs.setHeight( 8 );
bs.setWidth( QMIN( bs.height() * 8 / 6, widget->width() / 4 ) );
bs = bs.expandedTo( QApplication::globalStrut() );
if ( !( bs.width() % 2 ) )
bs.setWidth( bs.width() + 1 );
int extra = bs.height() * 2 == widget->height() ? 0 : 1;
int y = 0,
x = widget->width() - y - bs.width(),
lx = fw,
rx = x - fw * 2;
switch ( sc ) {
case SC_SpinWidgetUp:
return QRect( x, y, bs.width(), bs.height() );
case SC_SpinWidgetDown:
return QRect( x, y + bs.height(), bs.width(), bs.height() + extra );
case SC_SpinWidgetButtonField:
return QRect( x, y, bs.width(), widget->height() - 2 * fw );
case SC_SpinWidgetEditField:
return QRect( lx, fw, rx, widget->height() - 2 * fw );
case SC_SpinWidgetFrame:
return QRect( widget->x(), widget->y(), widget->width() - bs.width(), widget->height() );
}
}
default:
return KStyle::querySubControlMetrics( control, widget, sc, data );
}
}
int KlearlookStyle::pixelMetric( PixelMetric metric, const QWidget *widget ) const {
switch ( metric ) {
case PM_MenuButtonIndicator:
return 7;
case PM_MenuBarItemSpacing: {
return 5;
}
case PM_ButtonMargin:
return 5;
#if QT_VERSION >= 0x030200
case PM_TabBarTabShiftVertical: {
const QTabBar *tb = ::qt_cast<const QTabBar *>( widget );
return QTabBar::RoundedAbove == tb->shape() || QTabBar::TriangularAbove == tb->shape()
? 1
: -1;
}
case PM_TabBarTabShiftHorizontal:
return 0;
#endif
case PM_TabBarTabVSpace: {
const QTabBar * tb = ( const QTabBar * ) widget;
if ( tb->shape() == QTabBar::RoundedAbove ||
tb->shape() == QTabBar::RoundedBelow )
return 12;
else
return 4;
}
case PM_ButtonShiftHorizontal:
case PM_ButtonShiftVertical:
return 1;
case PM_ButtonDefaultIndicator:
return IND_BORDER == defBtnIndicator ? 1 : 0;
case PM_DefaultFrameWidth:
return borderFrame && widget && ( ::qt_cast<const QTabBar *>( widget ) ||
::qt_cast<const QWidgetStack *>( widget ) ||
::qt_cast<const QPopupMenu *>( widget ) )
? 2
: QTC_DEF_FRAME_WIDTH;
case PM_SpinBoxFrameWidth:
return 1;
case PM_MenuBarFrameWidth:
return 1;
case PM_IndicatorWidth:
case PM_IndicatorHeight:
return QTC_CHECK_SIZE;
case PM_ExclusiveIndicatorWidth:
case PM_ExclusiveIndicatorHeight:
return QTC_RADIO_SIZE;
case PM_TabBarTabOverlap:
return 1;
case PM_ProgressBarChunkWidth:
return 2;
case PM_DockWindowSeparatorExtent:
return 4;
case PM_DockWindowHandleExtent:
return 10;
case PM_SplitterWidth:
return 4;
case PM_ScrollBarSliderMin:
return 16;
case PM_ScrollBarExtent:
case PM_SliderControlThickness:
case PM_SliderThickness:
return 15;
case PM_SliderLength:
return 24;
case PM_MaximumDragDistance:
return -1;
default:
return KStyle::pixelMetric( metric, widget );
}
}
int KlearlookStyle::kPixelMetric( KStylePixelMetric kpm, const QWidget *widget ) const {
switch ( kpm ) {
case KPM_MenuItemSeparatorHeight:
return 4;
default:
return KStyle::kPixelMetric( kpm, widget );
}
}
QSize KlearlookStyle::sizeFromContents( ContentsType t,
const QWidget *widget,
const QSize &s,
const QStyleOption &opt ) const {
switch ( t ) {
case CT_PopupMenuItem: {
if ( !widget || opt.isDefault() )
return s;
const QPopupMenu *popup = dynamic_cast<const QPopupMenu *>( widget );
QMenuItem *mi = opt.menuItem();
int maxpmw = opt.maxIconWidth();
int w = s.width(), h = s.height();
bool checkable = popup->isCheckable();
if ( mi->custom() ) {
w = mi->custom() ->sizeHint().width();
h = mi->custom() ->sizeHint().height();
if ( !mi->custom() ->fullSpan() )
h += 4;
} else if ( mi->widget() ) {
// don't change the size in this case.
} else if ( mi->isSeparator() ) {
w = 20;
h = 8;
} else {
if ( mi->pixmap() ) {
h = QMAX( h, mi->pixmap() ->height() + 2 );
} else {
h = QMAX( h, 21 );
QSettings s;
if ( menuIcons )
h = QMAX( h, popup->fontMetrics().height() + MENU_POPUP_ITEM_HIGH_HI );
else
h = QMAX( h, popup->fontMetrics().height() + MENU_POPUP_ITEM_HIGH_LO );
}
if ( mi->iconSet() ) {
h = QMAX( h, mi->iconSet() ->pixmap( QIconSet::Small, QIconSet::Normal ).height() + 2 );
}
}
if ( !mi->text().isNull() && ( mi->text().find( '\t' ) >= 0 ) ) {
w += itemHMargin + itemFrame * 2 + 7;
} else if ( mi->popup() ) {
w += 2 * arrowHMargin;
}
if ( maxpmw ) {
w += maxpmw + 6;
}
if ( checkable && maxpmw < 20 ) {
w += 20 - maxpmw;
}
if ( checkable || maxpmw > 0 ) {
w += 12;
}
w += rightBorder;
return QSize( w-25, h );
}
case CT_PushButton: {
const QPushButton* btn = static_cast<const QPushButton*>( widget );
int w = s.width() + 2 * pixelMetric( PM_ButtonMargin, widget );
int h = s.height() + 2 * pixelMetric( PM_ButtonMargin, widget );
if ( btn->text().isEmpty() && s.width() < 32 )
return QSize( w, h );
// return button size
return QSize( w + 25, h + 3 );
}
case CT_ToolButton: {
if ( widget->parent() && ::qt_cast<QToolBar*>( widget->parent() ) )
return QSize( s.width() + 2 * 4, s.height() + 2 * 4 );
else {
return KStyle::sizeFromContents ( t, widget, s, opt );
}
}
default:
return KStyle::sizeFromContents ( t, widget, s, opt );
}
return KStyle::sizeFromContents ( t, widget, s, opt );
}
int KlearlookStyle::styleHint( StyleHint stylehint, const QWidget *widget, const QStyleOption &option, QStyleHintReturn *returnData ) const {
switch ( stylehint ) {
case SH_EtchDisabledText:
case SH_Slider_SnapToValue:
case SH_PrintDialog_RightAlignButtons:
case SH_FontDialog_SelectAssociatedText:
case SH_MenuBar_AltKeyNavigation:
case SH_MenuBar_MouseTracking:
case SH_PopupMenu_MouseTracking:
case SH_PopupMenu_SpaceActivatesItem:
case SH_ComboBox_ListMouseTracking:
case SH_ScrollBar_MiddleClickAbsolutePosition:
return 1;
case SH_MainWindow_SpaceBelowMenuBar:
return 0;
case SH_ComboBox_Popup:
return 0;
case SH_PopupMenu_SubMenuPopupDelay:
return 300;
case SH_PopupMenu_AllowActiveAndDisabled:
return 0;
default:
return KStyle::styleHint( stylehint, widget, option, returnData );
}
}
void KlearlookStyle::drawPBarOrMenu(
QPainter *p,
QRect const &r,
bool horiz,
const QColorGroup &cg,
bool menu ) const
{
switch ( pmProfile ) {
case PROFILE_SUNKEN:
drawGradientWithBorder( p, r, horiz );
break;
case PROFILE_RAISED: {
int flags = QStyle::Style_Raised;
if ( horiz )
flags |= Style_Horizontal;
drawLightBevel( p, r,
cg, flags, true,
menu ? ROUNDED_ALL : ROUNDED_NONE,
getFill( flags, menuPbar ),
menuPbar, true
);
break;
}
default:
p->fillRect( r, menuPbar[ GRADIENT_BASE ] );
break;
}
}
void KlearlookStyle::drawPBarOrMenu2(
QPainter *p,
QRect const &r,
bool horiz,
const QColorGroup &cg,
bool menu ) const
{
switch ( pmProfile ) {
case PROFILE_SUNKEN:
drawGradientWithBorder( p, r, horiz );
break;
case PROFILE_RAISED: {
int flags = QStyle::Style_Raised;
if ( horiz )
flags |= Style_Horizontal;
drawLightBevel( p, r,
cg, flags, true,
menu ? ROUNDED_TOP : ROUNDED_NONE,
getFill( flags, menuPbar ),
menuPbar, true
);
break;
}
default:
p->fillRect( r, menuPbar[ GRADIENT_BASE ] );
break;
}
}
void KlearlookStyle::drawGradientWithBorder(
QPainter *p,
QRect const &r,
bool horiz ) const
{
QRect r2( r );
drawGradient( menuPbar[ GRADIENT_TOP ],
menuPbar[ GRADIENT_BOTTOM ], true, borderFrame ? 2 : 1, p, r, horiz );
// 3d border effect...
if ( borderFrame ) {
p->setPen( menuPbar[ GRADIENT_BASE ] );
p->setBrush( NoBrush );
p->drawRect( r );
} else
r2.addCoords( -1, -1, 1, 1 );
p->setPen( menuPbar[ GRADIENT_LIGHT ] );
p->drawLine( r2.left() + 1, r2.top() + 1, r2.right() - 1, r2.top() + 1 );
p->drawLine( r2.left() + 1, r2.top() + 1, r2.left() + 1, r2.bottom() - 1 );
p->setPen( menuPbar[ GRADIENT_DARK ] );
p->drawLine( r2.left() + 1, r2.bottom() - 1, r2.right() - 1, r2.bottom() - 1 );
p->drawLine( r2.right() - 1, r2.bottom() - 1, r2.right() - 1, r2.top() + 1 );
}
void KlearlookStyle::drawBevelGradient(
const QColor &base,
bool increase,
int border,
QPainter *p,
QRect const &r,
bool horiz, double shadeTop, double shadeBot )
const {
//CPD TODO: Store last settings to make faster!
QColor top, bot;
if ( equal( 1.0, shadeTop ) )
top = base;
else
shade( base, &top, shadeTop );
if ( equal( 1.0, shadeBot ) )
bot = base;
else
shade( base, &bot, shadeBot );
drawGradient( top, bot, increase, border, p, r, horiz );
}
void KlearlookStyle::drawGradient(
const QColor &top,
const QColor &bot,
bool increase,
int border,
QPainter *p,
QRect const &r,
bool horiz ) const
{
if ( r.width() > 0 && r.height() > 0 ) {
QRect grad(
r.left() + border,
r.top() + border,
r.width() - ( border * 2 ),
r.height() - ( border * 2 )
);
if ( top == bot )
p->fillRect( grad, top );
else {
QRect grad(
r.left() + border,
r.top() + border,
r.width() - ( border * 2 ),
r.height() - ( border * 2 )
);
int i,
s = horiz ? grad.top() : grad.left(),
e = horiz ? grad.bottom() : grad.right();
double amt = ( horiz ? grad.height() : grad.width() ) ,
dr = ( ( double ) ( bot.red() - top.red() ) ) / amt ,
dg = ( ( double ) ( bot.green() - top.green() ) ) / amt ,
db = ( ( double ) ( bot.blue() - top.blue() ) ) / amt,
rc = 0, gc = 0, bc = 0;
if ( increase )
for ( i = s; i <= e ; i++ ) {
p->setPen( QColor(
limit( top.red() + rc ),
limit( top.green() + gc ),
limit( top.blue() + bc )
));
if ( horiz )
p->drawLine( grad.left(), i, grad.right(), i );
else
p->drawLine( i, grad.top(), i, grad.bottom() );
rc += dr;
gc += dg;
bc += db;
}
else
for ( i = e; i >= s; i-- ) {
p->setPen(
QColor(
limit( top.red() + rc ),
limit( top.green() + gc ),
limit( top.blue() + bc )
) );
if ( horiz )
p->drawLine( grad.left(), i, grad.right(), i );
else
p->drawLine( i, grad.top(), i, grad.bottom() );
rc += dr;
gc += dg;
bc += db;
}
}
}
}
void KlearlookStyle::drawPopupRect( QPainter *p, const QRect &r, const QColorGroup &cg ) const
{
const QColor *use = backgroundColors( cg );
p->setPen( use[ 4 ].light(70) );
p->setBrush( NoBrush );
p->drawRect( r );
}
void KlearlookStyle::drawSliderHandle(
QPainter *p,
const QRect &r,
const QColorGroup &cg, QStyle::SFlags flags
) const
{
const QColor * use = buttonColors( cg );
if ( r.width() > r.height() )
flags |= Style_Horizontal;
flags |= Style_Raised;
drawLightBevelButton( p, r, cg, flags, true, ROUNDED_ALL, getFill( flags, use ), use );
if ( GROOVE_NONE != sliderThumbs &&
( ( flags & Style_Horizontal && r.width() >= 14 ) || r.height() >= 14 ) )
drawLines( p, r,
r.width() < r.height(),
4, 3, use, 0,
GROOVE_SUNKEN == sliderThumbs,
APPEARANCE_LIGHT_GRADIENT == appearance );
}
void KlearlookStyle::drawSliderGroove
( QPainter *p,
const QRect &r,
QStyle::SFlags flags,
const QWidget *widget ) const
{
const QSlider * slider = ( const QSlider * ) widget;
QRect groove( r );
if ( flags & Style_HasFocus ) {
QRect fr( groove );
fr.addCoords( -1, -1, 1, 1 );
drawPrimitive( PE_FocusRect, p, fr, QColorGroup() );
}
if ( Qt::Horizontal == slider->orientation() ) {
int dh = ( groove.height() - 5 ) >> 1;
groove.addCoords( 0, dh, 0, -dh );
} else {
int dw = ( groove.width() - 5 ) >> 1;
groove.addCoords( dw, 0, -dw, 0 );
}
p->setBrush( gray[ 2 ] );
p->setPen( gray[ 5 ] );
p->drawRect( groove );
p->setPen( gray[ 4 ] );
p->drawLine( groove.x() + 1, groove.y() + 1, groove.x() + groove.width() - 2, groove.y() + 1 );
p->drawLine( groove.x() + 1, groove.y() + 1, groove.x() + 1, groove.y() + groove.height() - 2 );
}
void KlearlookStyle::shadeColors( const QColor &base, QColor *vals ) const {
QTC_SHADES
int i;
for ( i = 0; i < NUM_SHADES; ++i )
shade( base, &vals[ i ], QTC_SHADE( appearance, contrast, i ) );
vals[ NUM_SHADES ] = base;
}
const QColor * KlearlookStyle::buttonColors( const QColorGroup &cg ) const {
if ( cg.button() != button[ NUM_SHADES ] ) {
shadeColors( cg.button(), buttonColoured );
return buttonColoured;
}
return button;
}
const QColor * KlearlookStyle::backgroundColors( const QColorGroup &cg ) const {
if ( cg.background() != gray[ NUM_SHADES ] ) {
shadeColors( cg.background(), backgroundColoured );
return backgroundColoured;
}
return gray;
}
bool KlearlookStyle::redrawHoverWidget() {
if ( !hoverWidget )
return false;
QPoint cursor( QCursor::pos() ),
widgetZero( hoverWidget->mapToGlobal( QPoint( 0, 0 ) ) );
#if QT_VERSION >= 0x030200
//
// Qt>=3.2 sets the sensitive part of a check/radio to the image + label -> anything else
// is not sensitive. But,
// the widget can ocupy a larger area - and this whole are will react to mouse over.
// This needs to be coounteracted
// so that it looks as if only the sensitive area mouse-overs...
QRadioButton *rb = dynamic_cast<QRadioButton *>( hoverWidget );
if ( rb ) {
QRect rect( widgetZero.x(), widgetZero.y(),
visualRect( subRect( SR_RadioButtonFocusRect, rb ), rb ).width() +
pixelMetric( PM_ExclusiveIndicatorWidth ) + 4, hoverWidget->height() );
hover = rect.contains( cursor ) ? HOVER_RADIO : HOVER_NONE;
return ( HOVER_NONE != hover && !rect.contains( oldCursor ) ) ||
( HOVER_NONE == hover && rect.contains( oldCursor ) );
} else {
QCheckBox *cb = dynamic_cast<QCheckBox *>( hoverWidget );
if ( cb ) {
QRect rect( widgetZero.x(), widgetZero.y(),
visualRect( subRect( SR_CheckBoxFocusRect, cb ), cb ).width() +
pixelMetric( PM_IndicatorWidth ) + 4, hoverWidget->height() );
hover = rect.contains( cursor ) ? HOVER_CHECK : HOVER_NONE;
return ( HOVER_NONE != hover && !rect.contains( oldCursor ) ) ||
( HOVER_NONE == hover && rect.contains( oldCursor ) );
} else {
#endif
QScrollBar *sb = dynamic_cast<QScrollBar *>( hoverWidget );
if ( sb ) // So, are we over add button, sub button, slider, or none?
{
QRect subline( querySubControlMetrics( CC_ScrollBar, hoverWidget, SC_ScrollBarSubLine ) ),
addline( querySubControlMetrics( CC_ScrollBar, hoverWidget, SC_ScrollBarAddLine ) ),
slider( querySubControlMetrics( CC_ScrollBar, hoverWidget, SC_ScrollBarSlider ) );
subline.moveLeft( subline.x() + widgetZero.x() );
subline.moveTop( subline.y() + widgetZero.y() );
addline.moveLeft( addline.x() + widgetZero.x() );
addline.moveTop( addline.y() + widgetZero.y() );
slider.moveLeft( slider.x() + widgetZero.x() );
slider.moveTop( slider.y() + widgetZero.y() );
if ( slider.contains( cursor ) )
hover = HOVER_SB_SLIDER;
else if ( subline.contains( cursor ) )
hover = HOVER_SB_SUB;
else if ( addline.contains( cursor ) )
hover = HOVER_SB_ADD;
else
hover = HOVER_NONE;
return ( HOVER_SB_SLIDER == hover && !slider.contains( oldCursor ) ) ||
( HOVER_SB_SLIDER != hover && slider.contains( oldCursor ) ) ||
( HOVER_SB_SUB == hover && !subline.contains( oldCursor ) ) ||
( HOVER_SB_SUB != hover && subline.contains( oldCursor ) ) ||
( HOVER_SB_ADD == hover && !addline.contains( oldCursor ) ) ||
( HOVER_SB_ADD != hover && addline.contains( oldCursor ) );
} else {
#if KDE_VERSION >= 0x30400
QToolButton *tb = dynamic_cast<QToolButton *>( hoverWidget );
if ( tb ) {
hover = APP_KICKER == themedApp ? HOVER_KICKER : HOVER_NONE;
return HOVER_KICKER == hover;
} else {
#endif
QHeader *hd = dynamic_cast<QHeader *>( hoverWidget );
if ( hd ) {
// Hmm... this ones tricky, as there's only 1 widget - but it has different sections...
// and the ones that aren't clickable should not highlight on mouse over!
QRect rect(
widgetZero.x(),
widgetZero.y(),
hoverWidget->width(),
hoverWidget->height()
);
int s = 0;
bool redraw = false;
hover = rect.contains( cursor ) ? HOVER_HEADER : HOVER_NONE;
hoverSect = QTC_NO_SECT;
for ( s = 0; s < hd->count() && ( QTC_NO_SECT == hoverSect || !redraw ); ++s ) {
QRect r( hd->sectionRect( s ) );
r.moveLeft( r.x() + widgetZero.x() );
r.moveTop( r.y() + widgetZero.y() );
bool hasNew = r.contains( cursor );
if ( hasNew )
hoverSect = s;
if ( !redraw ) {
bool hasOld = r.contains( oldCursor );
if ( ( hasNew && !hasOld ) || ( !hasNew && hasOld ) )
redraw = true;
}
}
return redraw;
} else
return oldCursor == QPoint( -1, -1 );
#if KDE_VERSION >= 0x30400
}
#endif
}
#if QT_VERSION >= 0x030200
}
}
#endif
return false;
}
#define gdouble double
EDefBtnIndicator qtc_to_ind( const char *str ) {
if ( 0 == memcmp( str, "fontcolour", 10 ) )
return IND_FONT_COLOUR;
if ( 0 == memcmp( str, "border", 6 ) )
return IND_BORDER;
if ( 0 == memcmp( str, "none", 4 ) )
return IND_NONE;
return IND_CORNER;
}
EGroove qtc_to_groove( const char *str ) {
if ( 0 == memcmp( str, "raised", 6 ) )
return GROOVE_RAISED;
if ( 0 == memcmp( str, "none", 4 ) )
return GROOVE_NONE;
return GROOVE_SUNKEN;
}
ETBarBorder qtc_to_tbar_border( const char *str ) {
if ( 0 == memcmp( str, "dark", 4 ) )
return TB_DARK;
if ( 0 == memcmp( str, "none", 4 ) )
return TB_NONE;
if ( 0 == memcmp( str, "light", 5 ) )
return TB_LIGHT;
return TB_LIGHT;
}
ELvExpander qtc_to_lv_expander( const char *str ) {
return 0 == memcmp( str, "arrow", 5 ) ? LV_EXP_ARR : LV_EXP_PM;
}
ELvLines qtc_to_lv_lines( const char *str ) {
if ( 0 == memcmp( str, "none", 4 ) )
return LV_LINES_NONE;
if ( 0 == memcmp( str, "dotted", 6 ) )
return LV_LINES_DOTTED;
return LV_LINES_SOLID;
}
EProfile qtc_to_profile( const char *str ) {
if ( 0 == memcmp( str, "flat", 4 ) )
return PROFILE_FLAT;
if ( 0 == memcmp( str, "raised", 6 ) )
return PROFILE_RAISED;
return PROFILE_SUNKEN;
}
EAppearance qtc_to_appearance( const char *str ) {
if ( 0 == memcmp( str, "flat", 4 ) )
return APPEARANCE_FLAT;
if ( 0 == memcmp( str, "gradient", 8 ) )
return APPEARANCE_GRADIENT;
return APPEARANCE_LIGHT_GRADIENT;
}
#include "klearlook.moc"