2 files changed, 124 insertions, 18 deletions

diff --git a/noncore/styles/theme/othemestyle.cpp b/noncore/styles/theme/othemestyle.cpp
index 8c7a71b..a820efb 100644
--- a/noncore/styles/theme/othemestyle.cpp
+++ b/noncore/styles/theme/othemestyle.cpp
@@ -4,186 +4,266 @@
   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.
 */
 
 #include "othemestyle.h"
 #include "othemebase.h"
 #include <qpe/qpeapplication.h>
 #include <qbitmap.h>
 #define INCLUDE_MENUITEM_DEF
 #include <qmenudata.h>
 #include <qpopupmenu.h>
 #include <qtabbar.h>
 #include <qglobal.h>
+#include <qprogressbar.h>
 
 #include <limits.h>
 #include <stdio.h>
 
+typedef void (QStyle::*QDrawMenuBarItemImpl) (QPainter *, int, int, int, int, QMenuItem *,
+                          QColorGroup &, bool, bool);
+
+QDrawMenuBarItemImpl qt_set_draw_menu_bar_impl(QDrawMenuBarItemImpl impl);
+
+
+/* !! HACK !! Beware
+ * 
+ * TT forgot to make the QProgressBar widget styleable in Qt 2.x
+ * So the only way to customize the drawing, is to intercept the 
+ * paint event - since we have to use protected functions, we need
+ * to derive a "hack" class from QProgressBar and do the painting
+ * in there.
+ * 
+ * - sandman
+ */
+
+class HackProgressBar : public QProgressBar {
+public:
+        HackProgressBar ( );
+        
+        void paint ( QPaintEvent *event, OThemeStyle *style )
+        {
+                QPainter p( this );
+
+                if ( !contentsRect().contains( event->rect() ) ) {
+                        p.save();
+                        p.setClipRegion( event->region().intersect(frameRect()) );
+                        drawFrame( &p);
+                        p.restore();
+                }
+                if ( event->rect().intersects( contentsRect() ))  {
+                        p.setClipRegion( event->region().intersect( contentsRect() ) );
+
+                        int x, y, w, h;
+                        contentsRect ( ). rect ( &x, &y, &w, &h );
+
+                        int prog = progress ( );
+                        int total = totalSteps ( );
+                        if ( prog < 0 )
+                                prog = 0;
+                        if ( total <= 0 )
+                                total = 1;
+                        int perc = prog * 100 / total;
+
+                                style-> drawProgressBar ( &p, x, y, w, h, colorGroup ( ), perc );
+
+                                if ( progress ( ) >= 0 && totalSteps ( ) > 0 ) {                
+                                QString pstr;
+                                pstr. sprintf ( "%d%%", 100 * progress()/totalSteps ());
+                                p. setPen ( colorGroup().text());//g.highlightedText ( ));
+                                p. drawText (x,y,w-1,h-1,AlignCenter,pstr);
+                        }
+                }
+        }
+};
+
+
 #define QCOORDARRLEN(x) sizeof(x)/(sizeof(QCOORD)*2)
 
 OThemeStyle::OThemeStyle( const QString &configFile )
                 : OThemeBase( configFile )
 {
         setScrollBarExtent( getSBExtent(), getSBExtent() );
         setButtonDefaultIndicatorWidth( 0 ); // We REALLY should support one, see drawPushButton() below!
 }
 
 OThemeStyle::~OThemeStyle()
 {}
 
 void OThemeStyle::polish( QApplication * /*app*/ )
-{}
+{
+        qt_set_draw_menu_bar_impl((QDrawMenuBarItemImpl) &OThemeStyle::drawMenuBarItem);
+}
+
 
 void OThemeStyle::polish( QPalette &p )
 {
         oldPalette = p;
         
         QColor bg = oldPalette. color ( QPalette::Normal, QColorGroup::Background );
 
         if ( bgcolor. isValid ( ))
                 bg = bgcolor;
 
         if ( isColor ( Background )) 
                 bg = colorGroup ( oldPalette. active ( ), Background )-> background ( );
 
         p = QPalette ( bg, bg );
 
         if ( isPixmap( Background ) )
                 p. setBrush ( QColorGroup::Background, QBrush ( bg, *uncached ( Background )));
 
         if ( fgcolor. isValid ( )) {
                         p. setColor ( QColorGroup::Foreground, fgcolor );
                 p. setColor ( QColorGroup::ButtonText, fgcolor );
         }
         if ( selfgcolor. isValid ( ))
                         p. setColor ( QColorGroup::HighlightedText, selfgcolor );
         if ( selbgcolor. isValid ( ))
                         p. setColor ( QColorGroup::Highlight, selbgcolor );
         if ( winfgcolor. isValid ( )) 
                         p. setColor ( QColorGroup::Text, winfgcolor );
         if ( winbgcolor. isValid ( ))
                         p. setColor ( QColorGroup::Base, winbgcolor );
         
 }
 
 
 void OThemeStyle::unPolish( QApplication *app )
 {
+        qt_set_draw_menu_bar_impl ( 0 );
         app->setPalette( oldPalette, true );
 }
 
 void OThemeStyle::polish( QWidget *w )
 {
         if ( !w->isTopLevel() ) {
                 if ( w->inherits( "QGroupBox" )
                         || w->inherits( "QTabWidget" ) ) {
                         w->setAutoMask( TRUE );
                         return ;
                 }
                 if ( w->inherits( "QLabel" )
                         || w->inherits( "QSlider" )
                         || w->inherits( "QButton" )
                         || w->inherits( "QProgressBar" )
                    ) {
                         w->setBackgroundOrigin( QWidget::ParentOrigin );
                 }
         }
         if ( w->inherits( "QPopupMenu" ) ) {
                 popupPalette = w->palette();
                 if ( isColor( MenuItem ) || isColor( MenuItemDown ) ) {
                         QPalette newPal( w->palette() );
                         w->setPalettePropagation( QWidget::SamePalette );
                         if ( isColor( MenuItem ) ) {
                                 newPal.setNormal( *colorGroup( newPal.normal(), MenuItem ) );
                                 newPal.setDisabled( *colorGroup( newPal.normal(), MenuItem ) );
                         }
                         if ( isColor( MenuItemDown ) )
                                 newPal.setActive( *colorGroup( newPal.active(), MenuItemDown ) );
                         w->setPalette( newPal );
                 }
         }
-        if ( w->inherits( "QCheckBox" ) ) {
+        else if ( w->inherits( "QCheckBox" ) ) {
                 if ( isColor( IndicatorOff ) || isColor( IndicatorOn ) ) {
                         QPalette newPal( w->palette() );
                         w->setPalettePropagation( QWidget::SamePalette );
                         if ( isColor( IndicatorOff ) ) {
                                 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" ) ) {
+        else 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 );
                 }
         }
+        else if ( w-> inherits ( "QProgressBar" ) ) {
+                w-> installEventFilter ( this );
+        }
 }
 
 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" ) )
+        else if ( w->inherits( "QCheckBox" ) )
                 w->unsetPalette();
-        if ( w->inherits( "QRadioButton" ) )
+        else if ( w->inherits( "QRadioButton" ) )
                 w->unsetPalette();
+        else if ( w-> inherits ( "QProgressBar" ) )
+                w-> removeEventFilter ( this );
+}
+
+bool OThemeStyle::eventFilter ( QObject *obj, QEvent *ev )
+{
+        // only QProgressBar so far
+
+        if ( ev-> type ( ) == QEvent::Paint ) {
+                HackProgressBar *pb = (HackProgressBar *) obj;
+                pb-> paint ((QPaintEvent *) ev, this );
+                return true;
+        }
+        return false;
 }
 
 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,
@@ -1326,65 +1406,91 @@ void OThemeStyle::drawPopupMenuItem( QPainter* p, bool checkable, int maxpmw,
 void OThemeStyle::drawFocusRect( QPainter *p, const QRect &r,
                                  const QColorGroup &g, const QColor *c,
                                  bool atBorder )
 {
         p->setPen( g.dark() );
         if ( !is3DFocus() )
                 QWindowsStyle::drawFocusRect( p, r, g, c, atBorder );
         else {
                 int i = focusOffset();
                 p->drawLine( r.x() + i, r.y() + 1 + i, r.x() + i, r.bottom() - 1 - i );
                 p->drawLine( r.x() + 1 + i, r.y() + i, r.right() - 1 - i, r.y() + i );
                 p->setPen( g.light() );
                 p->drawLine( r.right() - i, r.y() + 1 + i, r.right() - i, r.bottom() - 1 - i );
                 p->drawLine( r.x() + 1 + i, r.bottom() - i, r.right() - 1 - i, r.bottom() - i );
         }
 }
 
 #if 0
 void OThemeStyle::drawKMenuBar( QPainter *p, int x, int y, int w, int h,
                                 const QColorGroup &g, bool, QBrush * )
 {
         drawBaseButton( p, x, y, w, h, *colorGroup( g, MenuBar ), false, false,
                         MenuBar );
 }
+#endif
 
-void OThemeStyle::drawKMenuItem( QPainter *p, int x, int y, int w, int h,
-                                 const QColorGroup &g, bool active,
-                                 QMenuItem *mi, QBrush * )
+void OThemeStyle::drawMenuBarItem( QPainter *p, int x, int y, int w, int h,
+                                 QMenuItem *mi, const QColorGroup &g, 
+                                 bool /*enabled*/, bool active )
 {
+    if(active){
+        x -= 2; // Bug in Qt/E 
+        y -= 2;
+        w += 2;
+        h += 2;
+    }
+
         const QColorGroup * cg = colorGroup( g, active ? MenuBarItem : MenuBar );
         QColor btext = cg->buttonText();
         if ( active )
                 drawBaseButton( p, x, y, w, h, *cg, false, false, MenuBarItem );
         //qDrawShadePanel(p, x, y, w, h, *cg, false, 1);
 
         drawItem( p, x, y, w, h, AlignCenter | ShowPrefix | DontClip | SingleLine,
-                  *cg, mi->isEnabled(), mi->pixmap(), mi->text(),
+                  *cg, mi-> isEnabled ( ), mi->pixmap(), mi->text(),
                   -1, &btext );
-        ;
 }
 
+
+
+void OThemeStyle::drawProgressBar ( QPainter *p, int x, int y, int w, int h, const QColorGroup &g, int percent )
+{
+        const QColorGroup * cg = colorGroup( g, ProgressBg );
+        QBrush bg;
+        bg.setColor( cg->color( QColorGroup::Background ) );
+        if ( isPixmap( ProgressBg ) )
+                bg.setPixmap( *uncached( ProgressBg ) );
+        
+        int pw = w * percent / 100;
+                
+                p-> fillRect ( x + pw, y, w - pw, h, bg ); // ### TODO
+        
+        drawBaseButton( p, x, y, pw, h, *cg, false, false, ProgressBar );
+}
+
+#if 0
+
 void OThemeStyle::drawKProgressBlock( QPainter *p, int x, int y, int w, int h,
                                       const QColorGroup &g, QBrush * )
 {
         drawBaseButton( p, x, y, w, h, *colorGroup( g, ProgressBar ), false, false,
                         ProgressBar );
 }
 
 void OThemeStyle::getKProgressBackground( const QColorGroup &g, QBrush &bg )
 {
         const QColorGroup * cg = colorGroup( g, ProgressBg );
         bg.setColor( cg->color( QColorGroup::Background ) );
         if ( isPixmap( ProgressBg ) )
                 bg.setPixmap( *uncached( ProgressBg ) );
 }
 #endif
 
 void OThemeStyle::tabbarMetrics( const QTabBar* t, int& hframe, int& vframe, int& overlap )
 {
         QCommonStyle::tabbarMetrics( t, hframe, vframe, overlap );
 }
 
 void OThemeStyle::drawTab( QPainter* p, const QTabBar* tb, QTab* t ,
                            bool selected )
 {
diff --git a/noncore/styles/theme/othemestyle.h b/noncore/styles/theme/othemestyle.h
index 52445c4..406b35b 100644
--- a/noncore/styles/theme/othemestyle.h
+++ b/noncore/styles/theme/othemestyle.h
@@ -5,85 +5,89 @@
   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>
 
+class QProgressBar;
+
 
 /**
  * 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 );
 
+        virtual bool eventFilter ( QObject *obj, QEvent *ev );
+
         /**
          * 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.
@@ -291,81 +295,77 @@ public:
          * 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,
                            QBrush *fill = NULL );
 #endif
         /**
          * Draw a menubar item.
          */
-#if 0
-
-        virtual void drawKMenuItem( QPainter *p, int x, int y, int w, int h,
-                                    const QColorGroup &g, bool active,
-                                    QMenuItem *item, QBrush *fill = NULL );
-#endif
+        virtual void drawMenuBarItem( QPainter *p, int x, int y, int w, int h,
+                                      QMenuItem *item, const QColorGroup &g, 
+                                      bool enabled, bool active );
         /**
          * Return the width of the splitter as specified in the config file.
          */
         virtual int splitterWidth() const;
         /**
          * Draw a splitter widget.
          */
         virtual void drawSplitter( QPainter *p, int x, int y, int w, int h,
                                    const QColorGroup &g, Orientation );
         /**
          * Draw a checkmark.
          */
         virtual void drawCheckMark( QPainter *p, int x, int y, int w, int h,
                                     const QColorGroup &g, bool act, bool dis );
         /**
          * Draw a menu item.
          *
          * Note: This method manually handles applying
          * inactive menu backgrounds to the entire widget.
          */
         virtual void drawPopupMenuItem( QPainter *p, bool checkable, int maxpmw,
                                         int tab, QMenuItem *mi, const QPalette &pal,
                                         bool act, bool enabled, int x, int y, int w,
                                         int h );
         int popupMenuItemHeight( bool checkable, QMenuItem *mi,
                                  const QFontMetrics &fm );
         /**
          * Draw the focus rectangle.
          */
         void drawFocusRect( QPainter *p, const QRect &r, const QColorGroup &g,
                             const QColor *c = 0, bool atBorder = false );
         /**
          * Draw a @ref KProgess bar.
          */ 
-        //    virtual void drawKProgressBlock(QPainter *p, int x, int y, int w, int h,
-        //                                    const QColorGroup &g, QBrush *fill);
+        virtual void drawProgressBar (QPainter *, int , int , int , int , const QColorGroup &, int );
         /**
          * Return the background for @ref KProgress.
          */ 
         //    virtual void getKProgressBackground(const QColorGroup &g, QBrush &bg);
         virtual void tabbarMetrics( const QTabBar*, int&, int&, int& );
         virtual void drawTab( QPainter*, const QTabBar*, QTab*, bool selected );
         virtual void drawTabMask( QPainter*, const QTabBar*, QTab*, bool selected );
 protected:
         QPalette oldPalette, popupPalette, indiPalette, exIndiPalette;
 
         class OThemeStylePrivate;
         OThemeStylePrivate *d;
 };
 
 #endif