2 files changed, 14 insertions, 0 deletions

diff --git a/noncore/styles/theme/othemestyle.cpp b/noncore/styles/theme/othemestyle.cpp
index 61127b8..d97b026 100644
--- a/noncore/styles/theme/othemestyle.cpp
+++ b/noncore/styles/theme/othemestyle.cpp
@@ -120,384 +120,392 @@ void OThemeStyle::polish( QWidget *w )
                                 newPal.setNormal( *colorGroup( newPal.normal(), IndicatorOff ) );
                                 newPal.setDisabled( *colorGroup( newPal.normal(), IndicatorOff ) );
                         }
                         if ( isColor( IndicatorOn ) )
                                 newPal.setActive( *colorGroup( newPal.active(), IndicatorOn ) );
                         w->setPalette( newPal );
                 }
         }
         if ( w->inherits( "QRadioButton" ) ) {
                 if ( isColor( ExIndicatorOff ) || isColor( ExIndicatorOn ) ) {
                         QPalette newPal( w->palette() );
                         w->setPalettePropagation( QWidget::SamePalette );
                         if ( isColor( ExIndicatorOff ) ) {
                                 newPal.setNormal( *colorGroup( newPal.normal(), ExIndicatorOff ) );
                                 newPal.setDisabled( *colorGroup( newPal.normal(),
                                                                  ExIndicatorOff ) );
                         }
                         if ( isColor( ExIndicatorOn ) )
                                 newPal.setActive( *colorGroup( newPal.active(), ExIndicatorOn ) );
                         w->setPalette( newPal );
                 }
         }
 }
 
 void OThemeStyle::unPolish( QWidget* w )
 {
         if ( !w->isTopLevel() ) {
                 if ( w->inherits( "QGroupBox" )
                         || w->inherits( "QTabWidget" ) ) {
                         w->setAutoMask( FALSE );
                         return ;
                 }
                 if ( w->inherits( "QLabel" )
                         || w->inherits( "QSlider" )
                         || w->inherits( "QButton" )
                         || w->inherits( "QProgressBar" )
                    ) {
                         w->setBackgroundOrigin( QWidget::WidgetOrigin );
                 }
         }
         if ( w->inherits( "QPopupMenu" ) )
                 w->unsetPalette();
         if ( w->inherits( "QCheckBox" ) )
                 w->unsetPalette();
         if ( w->inherits( "QRadioButton" ) )
                 w->unsetPalette();
 }
 
 void OThemeStyle::drawBaseButton( QPainter *p, int x, int y, int w, int h,
                                   const QColorGroup &g, bool sunken, bool
                                   rounded, WidgetType type, const QBrush * )
 {
         int offset = borderPixmap( type ) ? 0 : decoWidth( type );
         QPen oldPen = p->pen();
 
         // handle reverse bevel here since it uses decowidth differently
         if ( gradientHint( type ) == GrReverseBevel ) {
                 int i;
                 bitBlt( p->device(), x, y, scalePixmap( w, h, type ), 0, 0, w, h,
                         Qt::CopyROP, true );
                 p->setPen( g.text() );
                 for ( i = 0; i < borderWidth( type ); ++i, ++x, ++y, w -= 2, h -= 2 )
                         p->drawRect( x, y, w, h );
         }
         // same with KDE style borders
         else if ( !borderPixmap( type ) && shade() == KDE ) {
                 qDrawWinButton( p, x, y, w, h, g, sunken );
                 if ( isPixmap( type ) )
                         p->drawTiledPixmap( x + 4, y + 4, w - 6, h - 6,
                                             *scalePixmap( w - 6, h - 6,
                                                           type ) );
                 else
                         p->fillRect( x + 4, y + 4, w - 6, h - offset * 6,
                                      g.brush( QColorGroup::Button ) );
 
         }
         else {
                 if ( ( w - offset * 2 ) > 0 && ( h - offset * 2 ) > 0 ) {
                         if ( isPixmap( type ) )
                                 if ( rounded )
                                         p->drawTiledPixmap( x, y, w, h, *scalePixmap( w, h, type ) );
                                 else
                                         p->drawTiledPixmap( x + offset, y + offset, w - offset * 2,
                                                             h - offset * 2,
                                                             *scalePixmap( w - offset * 2, h - offset * 2,
                                                                           type ) );
                         else
                                 p->fillRect( x + offset, y + offset, w - offset * 2, h - offset * 2,
                                              g.brush( QColorGroup::Button ) );
                 }
                 if ( borderPixmap( type ) )
                         bitBlt( p->device(), x, y, scaleBorder( w, h, type ), 0, 0, w, h,
                                 Qt::CopyROP, false );
                 else
                         drawShade( p, x, y, w, h, g, sunken, rounded,
                                    highlightWidth( type ), borderWidth( type ), shade() );
         }
         p->setPen( oldPen );
 }
 
 void OThemeStyle::drawButton( QPainter *p, int x, int y, int w, int h,
                               const QColorGroup &g, bool sunken,
                               const QBrush *fill )
 {
         drawBaseButton( p, x, y, w, h, g, sunken, roundButton(), sunken ?
                         PushButtonDown : PushButton, fill );
 }
 
 void OThemeStyle::drawPushButton( QPushButton* btn, QPainter *p )
 {
         bool sunken = btn->isOn() || btn->isDown();
         int diw = buttonDefaultIndicatorWidth();
         drawBaseButton( p, diw, diw, btn->width() - 2 * diw, btn->height() - 2 * diw,
                         *colorGroup( btn->colorGroup(), sunken ? PushButtonDown :
                                      PushButton ), sunken, roundButton(),
                         sunken ? PushButtonDown : PushButton, NULL );
         // TODO if diw, draw fancy default button indicator
 }
 
 void OThemeStyle::drawBaseMask( QPainter *p, int x, int y, int w, int h,
                                 bool round )
 {
         // round edge fills
         static const QCOORD btm_left_fill[] = {
                                                   0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1,
                                                   1, 2, 2, 2, 3, 2, 4, 2, 2, 3, 3, 3, 4, 3, 3, 4, 4, 4
                                               };
 
         static const QCOORD btm_right_fill[] = {
                                                    0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 1, 1, 1, 2, 1, 3, 1, 4,
                                                    1, 0, 2, 1, 2, 2, 2, 3, 2, 0, 3, 1, 3, 2, 3, 0, 4, 1, 4
                                                };
 
         static const QCOORD top_left_fill[] = {
                                                   3, 0, 4, 0, 2, 1, 3, 1, 4, 1, 1, 2, 2, 2, 3, 2, 4, 2, 0, 3,
                                                   1, 3, 2, 3, 3, 3, 4, 3, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4
                                               };
 
         static const QCOORD top_right_fill[] = {
                                                    0, 0, 1, 0, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 2, 2, 3, 2, 0,
                                                    3, 1, 3, 2, 3, 3, 3, 4, 3, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4
                                                };
 
         QBrush fillBrush( color1, SolidPattern );
         p->setPen( color1 );
         if ( round && w > 19 && h > 19 ) {
                 int x2 = x + w - 1;
                 int y2 = y + h - 1;
                 QPointArray a( QCOORDARRLEN( top_left_fill ), top_left_fill );
                 a.translate( 1, 1 );
                 p->drawPoints( a );
                 a.setPoints( QCOORDARRLEN( btm_left_fill ), btm_left_fill );
                 a.translate( 1, h - 6 );
                 p->drawPoints( a );
                 a.setPoints( QCOORDARRLEN( top_right_fill ), top_right_fill );
                 a.translate( w - 6, 1 );
                 p->drawPoints( a );
                 a.setPoints( QCOORDARRLEN( btm_right_fill ), btm_right_fill );
                 a.translate( w - 6, h - 6 );
                 p->drawPoints( a );
 
                 p->fillRect( x + 6, y, w - 12, h, fillBrush );
                 p->fillRect( x, y + 6, x + 6, h - 12, fillBrush );
                 p->fillRect( x2 - 6, y + 6, x2, h - 12, fillBrush );
                 p->drawLine( x + 6, y, x2 - 6, y );
                 p->drawLine( x + 6, y2, x2 - 6, y2 );
                 p->drawLine( x, y + 6, x, y2 - 6 );
                 p->drawLine( x2, y + 6, x2, y2 - 6 );
 
         }
         else
                 p->fillRect( x, y, w, h, fillBrush );
 }
 
 void OThemeStyle::drawButtonMask( QPainter *p, int x, int y, int w, int h )
 {
         drawBaseMask( p, x, y, w, h, roundButton() );
 }
 
 void OThemeStyle::drawComboButtonMask( QPainter *p, int x, int y, int w, int h )
 {
         drawBaseMask( p, x, y, w, h, roundComboBox() );
 }
 
 void OThemeStyle::drawBevelButton( QPainter *p, int x, int y, int w, int h,
                                    const QColorGroup &g, bool sunken,
                                    const QBrush * )
 {
         WidgetType type = sunken ? BevelDown : Bevel;
         drawBaseButton( p, x, y, w, h, *colorGroup( g, type ), sunken, false, type );
 }
 
+void OThemeStyle::drawToolButton( QPainter *p, int x, int y, int w, int h,
+                                  const QColorGroup &g, bool sunken,
+                                  const QBrush * )
+{
+        WidgetType type = sunken ? ToolButtonDown : ToolButton;
+        drawBaseButton( p, x, y, w, h, *colorGroup( g, type ), sunken, false, type );
+}
+
 #if 0
 void OThemeStyle::drawKToolBarButton( QPainter *p, int x, int y, int w, int h,
                                       const QColorGroup &g, bool sunken,
                                       bool raised, bool enabled, bool popup,
                                       KToolButtonType type, const QString &btext,
                                       const QPixmap *pixmap, QFont *font,
                                       QWidget * )
 {
         QFont tmp_font( QString::fromLatin1( "Helvetica" ), 10 );
         if ( font )
                 tmp_font = *font;
         QFontMetrics fm( tmp_font );
         WidgetType widget = sunken ? ToolButtonDown : ToolButton;
 
         drawBaseButton( p, x, y, w, h, *colorGroup( g, widget ), sunken, false,
                         widget );
         int dx, dy;
         if ( type == Icon ) { // icon only
                 if ( pixmap ) {
                         dx = ( w - pixmap->width() ) / 2;
                         dy = ( h - pixmap->height() ) / 2;
                         if ( sunken ) {
                                 ++dx;
                                 ++dy;
                         }
                         p->drawPixmap( x + dx, y + dy, *pixmap );
                 }
         }
         else if ( type == IconTextRight ) { // icon and text (if any)
                 if ( pixmap ) {
                         dx = 4;
                         dy = ( h - pixmap->height() ) / 2;
                         if ( sunken ) {
                                 ++dx;
                                 ++dy;
                         }
                         p->drawPixmap( x + dx, y + dy, *pixmap );
                 }
                 if ( !btext.isNull() ) {
                         int tf = AlignVCenter | AlignLeft;
                         if ( pixmap )
                                 dx = 4 + pixmap->width() + 2;
                         else
                                 dx = 4;
                         dy = 0;
                         if ( sunken ) {
                                 ++dx;
                                 ++dy;
                         }
                         if ( font )
                                 p->setFont( *font );
                         if ( raised )
                                 p->setPen( KGlobalSettings::toolBarHighlightColor() );
                         p->drawText( x + dx, y + dy, w - dx, h, tf, btext );
                 }
         }
         else if ( type == Text ) { // only text, even if there is a icon
                 if ( !btext.isNull() ) {
                         int tf = AlignTop | AlignLeft;
                         if ( !enabled )
                                 p->setPen( g.dark() );
                         dx = ( w - fm.width( btext ) ) / 2;
                         dy = ( h - fm.lineSpacing() ) / 2;
                         if ( sunken ) {
                                 ++dx;
                                 ++dy;
                         }
                         if ( font )
                                 p->setFont( *font );
                         if ( raised )
                                 p->setPen( KGlobalSettings::toolBarHighlightColor() );
                         p->drawText( x + dx, y + dy, fm.width( btext ), fm.lineSpacing(), tf, btext );
                 }
         }
         else if ( type == IconTextBottom ) {
                 if ( pixmap ) {
                         dx = ( w - pixmap->width() ) / 2;
                         dy = ( h - fm.lineSpacing() - pixmap->height() ) / 2;
                         if ( sunken ) {
                                 ++dx;
                                 ++dy;
                         }
                         p->drawPixmap( x + dx, y + dy, *pixmap );
                 }
                 if ( !btext.isNull() ) {
                         int tf = AlignBottom | AlignHCenter;
                         dx = ( w - fm.width( btext ) ) / 2;
                         dy = h - fm.lineSpacing() - 4;
                         if ( sunken ) {
                                 ++dx;
                                 ++dy;
                         }
                         if ( font )
                                 p->setFont( *font );
                         if ( raised )
                                 p->setPen( KGlobalSettings::toolBarHighlightColor() );
                         p->drawText( x + dx, y + dy, fm.width( btext ), fm.lineSpacing(), tf, btext );
                 }
         }
         if ( popup ) {
                 if ( enabled )
                         qDrawArrow ( p, DownArrow, WindowsStyle, false, w - 5, h - 5, 0, 0,
                                      g, true );
                 else
                         qDrawArrow ( p, DownArrow, WindowsStyle, false, w - 5, h - 5,
                                      0, 0, g, false );
         }
 }
 
 void OThemeStyle::drawKBarHandle( QPainter *p, int x, int y, int w, int h,
                                   const QColorGroup &g, KToolBarPos, QBrush * )
 {
         if ( w > h )
                 drawBaseButton( p, x, y, w, h, *colorGroup( g, HBarHandle ), false, false,
                                 HBarHandle );
         else
                 drawBaseButton( p, x, y, w, h, *colorGroup( g, VBarHandle ), false, false,
                                 VBarHandle );
 }
 
 void OThemeStyle::drawKToolBar( QPainter *p, int x, int y, int w, int h,
                                 const QColorGroup &g, KToolBarPos, QBrush * )
 {
         drawBaseButton( p, x, y, w, h, *colorGroup( g, ToolBar ), false, false,
                         ToolBar );
 }
 #endif
 
 QRect OThemeStyle::buttonRect( int x, int y, int w, int h )
 {
         int spacing = decoWidth( PushButton ) > decoWidth( PushButtonDown ) ?
                       decoWidth( PushButton ) : decoWidth( PushButtonDown );
         return ( QRect( x + spacing, y + spacing, w - ( spacing * 2 ), h - ( spacing * 2 ) ) );
 }
 
 void OThemeStyle::drawComboButton( QPainter *p, int x, int y, int w, int h,
                                    const QColorGroup &g, bool sunken, bool,
                                    bool, const QBrush * )
 {
         WidgetType widget = sunken ? ComboBoxDown : ComboBox;
         drawBaseButton( p, x, y, w, h, *colorGroup( g, widget ), sunken,
                         roundComboBox(), widget );
         if ( !sunken && isPixmap( ComboDeco ) )
                 p->drawPixmap( w - uncached( ComboDeco ) ->width() -
                                decoWidth( ComboBox ) - 2,
                                y + ( h - uncached( ComboDeco ) ->
                                      height() ) / 2, *uncached( ComboDeco ) );
         else if ( sunken && isPixmap( ComboDecoDown ) )
                 p->drawPixmap( w - uncached( ComboDecoDown ) ->width() -
                                decoWidth( ComboBoxDown ) - 2,
                                y + ( h - uncached( ComboDecoDown ) ->
                                      height() ) / 2, *uncached( ComboDecoDown ) );
         else {
                 qDrawArrow( p, Qt::DownArrow, Qt::MotifStyle, false, w - 15, y + 6, 10,
                             h - 15, *colorGroup( g, widget ), true );
                 qDrawShadeRect( p, w - 14, y + 7 + ( h - 15 ), 10, 3, *colorGroup( g, widget ) );
         }
 }
 
 void OThemeStyle::drawScrollBarControls( QPainter *p, const QScrollBar *sb,
         int sliderStart, uint controls,
         uint activeControl )
 {
         int sliderMin, sliderMax, sliderLength, buttonDim;
         QRect add
                 , sub, addPage, subPage, slider;
         int addX, addY, subX, subY;
         bool horizontal = sb->orientation() == QScrollBar::Horizontal;
         int len = ( horizontal ) ? sb->width() : sb->height();
         int extent = ( horizontal ) ? sb->height() : sb->width();
         int offset = decoWidth( horizontal ? HScrollGroove : VScrollGroove );
         QColorGroup g = sb->colorGroup();
 
         scrollBarMetrics( sb, sliderMin, sliderMax, sliderLength, buttonDim );
         if ( sliderStart > sliderMax )
                 sliderStart = sliderMax;
 
         int sliderEnd = sliderStart + sliderLength;
         int sliderWidth = extent - offset * 2;
 
         // Scary button placement code >:-P Feel free to improve this if you
         // want. I get a headache just looking at it... (mosfet)
         if ( scrollBarLayout() == SBOpposite ) {
                 if ( horizontal ) {
                         subY = addY = ( extent - buttonDim ) / 2;
                         subX = offset;
                         addX = len - buttonDim - offset;
                 }
                 else {
                         subX = addX = ( extent - buttonDim ) / 2;
                         subY = offset;
                         addY = len - buttonDim - offset;
diff --git a/noncore/styles/theme/othemestyle.h b/noncore/styles/theme/othemestyle.h
index 02bec78..52445c4 100644
--- a/noncore/styles/theme/othemestyle.h
+++ b/noncore/styles/theme/othemestyle.h
@@ -1,303 +1,309 @@
 /* This file is part of the KDE libraries
   Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
 */
 #ifndef __KTHEMESTYLE_H
 #define __KTHEMESTYLE_H
 
 #include "othemebase.h"
 #include <qwindowdefs.h>
 #include <qobject.h>
 #include <qbutton.h>
 #include <qpushbutton.h>
 #include <qscrollbar.h>
 #include <qstring.h>
 
 
 /**
  * KDE themed styles.
  *
  * It provides methods for
  * drawing most widgets with user-specified borders, highlights, pixmaps,
  * etc. It also handles various other settings such as scrollbar types,
  * rounded buttons, and shading types. For a full list of parameters this
  * class handles refer to the KDE theme configuration documentation.
  *
  */
 
 class OThemeStyle: public OThemeBase
 {
         Q_OBJECT
 public:
         /**
          * Construct a new @ref OThemeStyle object.
          *
          * @param configFile A KConfig file to use as the theme configuration.
          * Defaults to ~/.kderc.
          */
         OThemeStyle( const QString &configFile = QString::null );
         ~OThemeStyle();
         virtual void polish( QWidget* );
         virtual void unPolish( QWidget* );
         /**
          * By default this just sets the background brushes to the pixmapped
          * background.
          */
         virtual void polish( QApplication *app );
         virtual void unPolish( QApplication* );
 
         /// @internal
         // to make it possible for derived classes to overload this function
         virtual void polish( QPalette& pal );
 
         /**
          * This is a convenience method for drawing widgets with
          * borders, highlights, pixmaps, colors, etc...
          * You specify the widget type and it will draw it according to the
          * config file settings.
          *
          * @param p The QPainter to draw on.
          * @param g The color group to use.
          * @param rounded @p true if the widget is rounded, @p false if rectangular.
          * @param type The widget type to paint.
          * @param fill An optional fill brush. Currently ignored (the config file
          * is used instead).
          */
         virtual void drawBaseButton( QPainter *p, int x, int y, int w, int h,
                                      const QColorGroup &g, bool sunken = FALSE,
                                      bool rounded = FALSE, WidgetType type = Bevel,
                                      const QBrush *fill = 0 );
         /**
          * Draw a mask with for widgets that may be rounded. 
          *
          *Currently used
          * by pushbuttons and comboboxes.
          *
          * @param p The QPainter to draw on.
          * @param rounded @p true if the widget is rounded, @p false if rectangular.
          */
         virtual void drawBaseMask( QPainter *p, int x, int y, int w, int h,
                                    bool rounded );
         /**
          * Draw a pushbutton.
          *
          * This calls @ref drawBaseButton() with @p PushButton as the
          * widget type.
          */
         virtual void drawButton( QPainter *p, int x, int y, int w, int h,
                                  const QColorGroup &g, bool sunken = FALSE,
                                  const QBrush *fill = 0 );
         /**
          * Draw a bevel button.
          *
          * This calls @ref drawBaseButton() with Bevel as the
          * widget type.
          */
         virtual void drawBevelButton( QPainter *p, int x, int y, int w, int h,
                                       const QColorGroup &g, bool sunken = FALSE,
                                       const QBrush *fill = 0 );
+        /**
+         * Draw a toolbar button.
+         */
+        virtual void drawToolButton ( QPainter *p, int x, int y, int w, int h,
+                                      const QColorGroup &g, bool sunken = FALSE,
+                                      const QBrush *fill = 0 );
 #if 0
         /**
          * Draw a toolbar button.
          */
         virtual void drawKToolBarButton( QPainter *p, int x, int y, int w, int h,
                                          const QColorGroup &g, bool sunken = false,
                                          bool raised = true, bool enabled = true,
                                          bool popup = false, KToolButtonType type = Icon,
                                          const QString &btext = QString::null,
                                          const QPixmap *icon = NULL,
                                          QFont *font = NULL, QWidget *btn = NULL );
         /**
          * Draw the handle used in toolbars.
          */
         void drawKBarHandle( QPainter *p, int x, int y, int w, int h,
                              const QColorGroup &g,
                              KToolBarPos type, QBrush *fill = NULL );
 
         /**
          * Draw a toolbar.
          */
         void drawKToolBar( QPainter *p, int x, int y, int w, int h,
                            const QColorGroup &g, KToolBarPos type,
                            QBrush *fill = NULL );
 #endif
         /**
          * Return the space available in a pushbutton, taking configurable
          * borders and highlights into account.
          */
         virtual QRect buttonRect( int x, int y, int w, int h );
         /**
          * Draw an arrow in the style specified by the config file.
          */
         virtual void drawArrow( QPainter *p, Qt::ArrowType type, bool down,
                                 int x, int y, int w, int h, const QColorGroup &g,
                                 bool enabled = true, const QBrush *fill = 0 );
         /**
          * Return the size of the exclusive indicator pixmap if one is specified
          * in the config file, otherwise it uses the base style's size.
          */
         virtual QSize exclusiveIndicatorSize() const;
         /**
          * Draw an exclusive indicator widget.
          *
          * If a pixmap is specified in the
          * config file that is used, otherwise the base style's widget is drawn.
          */
         virtual void drawExclusiveIndicator( QPainter* p, int x, int y, int w,
                                              int h, const QColorGroup &g, bool on,
                                              bool down = FALSE,
                                              bool enabled = TRUE );
         /**
          * Set the mask of an exclusive indicator widget.
          *
          * If a pixmap is specified
          * it is masked according to it's transparent pixels, otherwise the
          * base style's mask is used.
          */
         virtual void drawExclusiveIndicatorMask( QPainter *p, int x, int y, int w,
                 int h, bool on );
         /**
          * Set the mask of an indicator widget.
          *
          * If a pixmap is specified
          * it is masked according to it's transparent pixels, otherwise the
          * base style's mask is used.
          */
         virtual void drawIndicatorMask( QPainter *p, int x, int y, int w, int h,
                                         int state );
         /**
          * Set the mask for pushbuttons.
          */
         virtual void drawButtonMask( QPainter *p, int x, int y, int w, int h );
         /**
          * Set the mask for combo boxes.
          */
         virtual void drawComboButtonMask( QPainter *p, int x, int y, int w, int h );
         /**
          * Return the size of the indicator pixmap if one is specified
          * in the config file, otherwise it uses the base style's size.
          */
         virtual QSize indicatorSize() const;
         /**
          * Draw an indicator widget.
          *
          * If a pixmap is specified in the
          * config file that is used, otherwise the base style's widget is drawn.
          */
         virtual void drawIndicator( QPainter* p, int x, int y, int w, int h,
                                     const QColorGroup &g, int state,
                                     bool down = FALSE, bool enabled = TRUE );
         /**
          * Draw a combobox.
          */
         virtual void drawComboButton( QPainter *p, int x, int y, int w, int h,
                                       const QColorGroup &g, bool sunken = FALSE,
                                       bool editable = FALSE, bool enabled = TRUE,
                                       const QBrush *fill = 0 );
         /**
          * Draw a pushbutton.
          */
         virtual void drawPushButton( QPushButton* btn, QPainter *p );
         /**
          * Return the amount of button content displacement specified by the
          * config file.
          */
         virtual void getButtonShift( int &x, int &y );
         /**
          * Return the frame width.
          */
         virtual int defaultFrameWidth() const;
         /**
          * Calculate the metrics of the scrollbar controls according to the
          * layout specified by the config file.
          */
         virtual void scrollBarMetrics( const QScrollBar*, int&, int&, int&, int& );
         /**
          * Draw a themed scrollbar.
          */
         virtual void drawScrollBarControls( QPainter*, const QScrollBar*,
                                             int sliderStart, uint controls,
                                             uint activeControl );
         /**
          * Return the control that the given point is over according to the
          * layout in the config file.
          */
         virtual ScrollControl scrollBarPointOver( const QScrollBar*,
                 int sliderStart, const QPoint& );
         /**
          * Return the configurable default slider length.
          */
         virtual int sliderLength() const;
         /**
          * Draw a slider control.
          */
         virtual void drawSlider( QPainter *p, int x, int y, int w, int h,
                                  const QColorGroup &g, Orientation, bool tickAbove,
                                  bool tickBelow );
         /**
          * Draw a slider groove.
          */
         void drawSliderGroove( QPainter *p, int x, int y, int w, int h,
                                const QColorGroup& g, QCOORD c,
                                Orientation );
         /**
          * Draw the mask for a slider (both the control and groove.
          */
         virtual void drawSliderMask( QPainter *p, int x, int y, int w, int h,
                                      Orientation, bool tickAbove, bool tickBelow );
         //    void drawSliderGrooveMask(QPainter *p,int x, int y, int w, int h,
         //                              QCOORD c, Orientation );
         /**
          * Convience method for drawing themed scrollbar grooves.
          *
          * Since the
          * grooves may be a scaled pixmap you cannot just bitblt the pixmap at
          * any offset. This generates a cached pixmap at full size if needed and
          * then copies the requested area.
          *
          * @param p The painter to draw on.
          * @param sb The scrollbar (usually given by drawScrollBarControls).
          * @param horizontal Is the scrollBar horizontal?
          * @param r The rectangle to fill.
          * @param g The color group to use.
          */
         virtual void drawScrollBarGroove( QPainter *p, const QScrollBar *sb,
                                           bool horizontal, QRect r, QColorGroup g );
         /**
          * Draw a shaded rectangle using the given style.
          *
          * @param p The painter to draw on.
          * @param g The color group to use.
          * @param rounded Draws a rounded shape if true. Requires bWidth to be
          * at least 1.
          * @param hWidth The highlight width.
          * @param bWidth The border width.
          * @param style The shading style to use.
          */
         virtual void drawShade( QPainter *p, int x, int y, int w, int h,
                                 const QColorGroup &g, bool sunken, bool rounded,
                                 int hWidth, int bWidth, ShadeStyle style );
         /**
          * Draw the text for a pushbutton.
          */
         virtual void drawPushButtonLabel( QPushButton *btn, QPainter *p );
         /**
          * Draw a menubar.
          */
 #if 0
 
         void drawKMenuBar( QPainter *p, int x, int y, int w, int h,
                            const QColorGroup &g, bool macMode,