1 files changed, 3 insertions, 4 deletions

diff --git a/noncore/styles/phase/phasestyle.cpp b/noncore/styles/phase/phasestyle.cpp
index fb6411c..139505f 100644
--- a/noncore/styles/phase/phasestyle.cpp
+++ b/noncore/styles/phase/phasestyle.cpp
@@ -1,1221 +1,1220 @@
 //////////////////////////////////////////////////////////////////////////////
 // phasestyle.h
 // -------------------
 // A style for KDE
 // -------------------
 // Copyright (c) 2004 David Johnson <david@usermode.org>
 //
 // 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 "phasestyle.h"
 
 #include "bitmaps.h"
 
 #define INCLUDE_MENUITEM_DEF
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qtoolbutton.h>
 #include <qpainter.h>
 #include <qbrush.h>
 #include <qiconset.h>
 #include <qtabbar.h>
 #include <qscrollbar.h>
 
 
 /* Spacing and sizeHint */
 static unsigned contrast = 110;
 
 static const int ITEMFRAME       = 1; // menu stuff
 static const int ITEMHMARGIN     = 3;
 static const int ITEMVMARGIN     = 0;
 
 static const int ARROWMARGIN     = 6;
 static const int RIGHTBORDER     = 10;
 static const int MINICONSIZE     = 12;
 static const int CHECKSIZE       = 9;
 static const int SCROLLBAR_EXTENT = 12;
 
 
 /*
  * Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>
  * LGPLv2 from kdelibs/kdefx/kdrawutil.cpp
  */
 void kColorBitmaps(QPainter *p, const QColorGroup &g, int x, int y,
                    QBitmap *lightColor, QBitmap *midColor,
                    QBitmap *midlightColor, QBitmap *darkColor,
                    QBitmap *blackColor, QBitmap *whiteColor)
 {
     QBitmap *bitmaps[]={lightColor, midColor, midlightColor, darkColor,
         blackColor, whiteColor};
 
     QColor colors[]={g.light(), g.mid(), g.midlight(), g.dark(),
         Qt::black, Qt::white};
 
     int i;
     for(i=0; i < 6; ++i){
         if(bitmaps[i]){
             if(!bitmaps[i]->mask())
                 bitmaps[i]->setMask(*bitmaps[i]);
             p->setPen(colors[i]);
             p->drawPixmap(x, y, *bitmaps[i]);
         }
     }
 }
 
 
 /*
  * drawMenuBarItem is not virtual
  * this way we define our draw handler
  */
 typedef void (QStyle::*QDrawMenuBarItemImpl) (QPainter *, int, int, int, int, QMenuItem *,
                           QColorGroup &, bool, bool);
 
 extern QDrawMenuBarItemImpl qt_set_draw_menu_bar_impl(QDrawMenuBarItemImpl impl);
 
 
 PhaseStyle::PhaseStyle()
     : QWindowsStyle()
 {
     setName( "PhaseStyle" );
 
     /* small default sizes */
     setButtonDefaultIndicatorWidth(1);
     setScrollBarExtent(SCROLLBAR_EXTENT, SCROLLBAR_EXTENT);
     setSliderThickness(12);
     setButtonMargin( 1 );
 
     // create bitmaps
     uarrow = QBitmap(6, 6, uarrow_bits, true);
     uarrow.setMask(uarrow);
     darrow = QBitmap(6, 6, darrow_bits, true);
     darrow.setMask(darrow);
     larrow = QBitmap(6, 6, larrow_bits, true);
     larrow.setMask(larrow);
     rarrow = QBitmap(6, 6, rarrow_bits, true);
     rarrow.setMask(rarrow);
     bplus = QBitmap(6, 6, bplus_bits, true);
     bplus.setMask(bplus);
     bminus = QBitmap(6, 6, bminus_bits, true);
     bminus.setMask(bminus);
     bcheck = QBitmap(9, 9, bcheck_bits, true);
     bcheck.setMask(bcheck);
     dexpand = QBitmap(9, 9, dexpand_bits, true);
     dexpand.setMask(dexpand);
     rexpand = QBitmap(9, 9, rexpand_bits, true);
     rexpand.setMask(rexpand);
     doodad_mid = QBitmap(4, 4, doodad_mid_bits, true);
     doodad_light = QBitmap(4, 4, doodad_light_bits, true);
 }
 
 PhaseStyle::~PhaseStyle() {
     /* deleted by Qt */
 }
 
 void PhaseStyle::drawCheckMark ( QPainter * p, int x, int y, int w,
                                  int h, const QColorGroup & g,
                                  bool , bool) {
     p->setPen(g.text());
     p->drawPixmap(x+w/2-4, y+h/2-4, bcheck);
 }
 
 void PhaseStyle::drawArrow(QPainter *painter, Qt::ArrowType type, bool down,
                            int x, int y, int w, int h, const QColorGroup &group,
                            bool enabled , const QBrush * ) {
     switch( type ) {
     case UpArrow:
         if (enabled)
             painter->setPen(down ? group.midlight() : group.dark());
         else painter->setPen(group.mid());
         painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow);
         break;
     case DownArrow:
         if (enabled) painter->setPen(down ? group.midlight() : group.dark());
         else painter->setPen(group.mid());
         painter->drawPixmap(x+w/2-3, y+h/2-3, darrow);
         break;
     case LeftArrow:
         if (enabled) painter->setPen(down ? group.midlight() : group.dark());
         else painter->setPen(group.mid());
         painter->drawPixmap(x+w/2-3, y+h/2-3, larrow);
         break;
     case RightArrow:
         if (enabled) painter->setPen(down ? group.midlight() : group.dark());
         else painter->setPen(group.mid());
         painter->drawPixmap(x+w/2-3, y+h/2-3, rarrow);
         break;
     }
 }
 
 void PhaseStyle::drawPushButton(QPushButton *btn, QPainter *painter) {
     QRect r = btn->rect();
     int x = r.x();
     int y = r.y();
     int h = r.height();
     int w = r.width();
     bool depress = btn->isOn() || btn->isDown();
     QColorGroup group = btn->colorGroup();
     QBrush brush(group.button() );
 //    int bd = pixelMetric(PM_ButtonDefaultIndicator, widget) + 1;
     static int bd = 2;
 
     if (btn->isDefault() && !depress) {
         drawPanel(painter, x, y, h, w, group,
                   &group.brush(QColorGroup::Mid), true);
         drawBevelButton(painter, x+bd, y+bd, w-bd*2, h-bd*2, group,
                         false, &brush  );
     } else {
         drawButton(painter, x, y, w, h, group, depress,
                    &brush );
     }
 
     if (btn->hasFocus() ) { // draw focus
         QColor col;
         drawFocusRect(painter, r, group,
                       &col, false );
     }
 }
 
 
 void PhaseStyle::drawPanel(QPainter* painter, int x, int y, int w, int h,
                            const QColorGroup& group, bool sunken,
                            int , const QBrush* fill) {
     int x2 = x + w - 1;
     int y2 = y + h - 1;
     painter->save();
 
     if (sunken) {
         painter->setPen(group.dark());
         painter->drawRect(x+1, y+1, w-2, h-2);
         painter->setPen(group.midlight());
         painter->drawLine(x+1, y2, x2, y2);
         painter->drawLine(x2, y+1, x2, y2-1);
         painter->setPen(group.mid());
         painter->drawLine(x, y, x, y2-1);
         painter->drawLine(x+1, y, x2-1, y);
         painter->setPen(group.background());
         painter->drawPoint(x, y2);
         painter->drawPoint(x2, y);
     } else {
         painter->setPen(group.dark());
         painter->drawRect(x, y, w, h);
         painter->setPen(group.midlight());
         painter->drawLine(x+1, y+1, x2-2, y+1);
         painter->drawLine(x+1, y+2, x+1, y2-2);
         painter->setPen(group.mid());
         painter->drawLine(x+2, y2-1, x2-1, y2-1);
         painter->drawLine(x2-1, y+2, x2-1, y2-2);
         painter->setPen(group.background());
         painter->drawPoint(x+1, y2-1);
         painter->drawPoint(x2-1, y+1);
     }
 
     if (fill) {
         painter->fillRect(x+2, y+2, w-4, h-4, *fill );
     }
     painter->restore();
 }
 
 
 
 void  PhaseStyle::drawButton(QPainter *p, int x, int y, int w, int h,
                              const QColorGroup &group, bool sunken ,
                              const QBrush *fill  ) {
     int x2 = x + w - 1;
     int y2 = y + h - 1;
 
     p->setPen(group.midlight());
     p->drawLine(x+1, y2, x2, y2);
     p->drawLine(x2, y+1, x2, y2-1);
 
     p->setPen(group.mid());
     p->drawLine(x, y,  x2-1, y);
     p->drawLine(x, y+1, x, y2-1);
 
     p->setPen(group.button());
     p->drawPoint(x, y2);
     p->drawPoint(x2, y);
 
     drawBevelButton(p, x+1, y+1, w-2, h-2, group, sunken,
                     fill);
 }
 
 void PhaseStyle::drawButtonMask( QPainter* p, int x, int y,
                                  int w, int h ) {
     QRect rect(x, y, w, h );
     p->fillRect(rect, Qt::color1);
     p->setPen(Qt::color0);
 }
 
 
 void PhaseStyle::drawBevelButton(QPainter* p, int x, int y,
                                  int w, int h, const QColorGroup& group,
                                  bool sunken, const QBrush* fill ) {
     int x2 = x + w - 1;
     int y2 = y + h - 1;
     p->save();
 
     p->setPen(group.dark());
     p->drawRect(x, y, w, h);
 
     p->setPen(sunken ? group.mid() : group.midlight());
     p->drawLine(x+1, y+1, x2-2, y+1);
     p->drawLine(x+1, y+2, x+1, y2-2);
 
     p->setPen(sunken ? group.midlight() : group.mid());
     p->drawLine(x+2, y2-1, x2-1, y2-1);
     p->drawLine(x2-1, y+2, x2-1, y2-2);
 
     p->setPen(group.button());
     p->drawPoint(x+1, y2-1);
     p->drawPoint(x2-1, y+1);
 
     QBrush b = fill ? *fill : group.brush( QColorGroup::Button );
     if (sunken) {
         // sunken bevels don't get gradients
         p->fillRect(x+2, y+2, w-4, h-4, b);
     } else
         drawPhaseGradient(p, QRect(x+2, y+2, w-4, h-4), b.color() );
 
     p->restore();
 }
 
 void PhaseStyle::drawPhaseGradient(QPainter* painter,
                                    const QRect& rect,
                                    const QColor& color )const {
     painter->fillRect(rect, color);
 }
 
 void PhaseStyle::polish( QWidget* widget ) {
     QWindowsStyle::polish(widget );
 
 #if 0
     if (widget->inherits("QMenuBar")    ||
         widget->inherits("QPopupMenu" ) ||
         widget->inherits("QToolButton") ||
         widget->inherits("QHeader" )   ) {
         widget->setBackgroundMode(QWidget::NoBackground);
     }
 //    else if (widget->inherits("QFrame") ) {
 //        widget->installEventFilter(this);
 //    }
 #endif
 }
 
 void PhaseStyle::polish( QPalette &pal ) {
     QWindowsStyle::polish( pal );
     // lighten up a bit, so the look is not so "crisp"
     if (QPixmap::defaultDepth() > 8) { // but not on low color displays
         pal.setColor(QPalette::Disabled, QColorGroup::Dark,
                      pal.color(QPalette::Disabled, QColorGroup::Dark).light(contrast));
         pal.setColor(QPalette::Active, QColorGroup::Dark,
                      pal.color(QPalette::Active, QColorGroup::Dark).light(contrast));
         pal.setColor(QPalette::Inactive, QColorGroup::Dark,
                      pal.color(QPalette::Inactive, QColorGroup::Dark).light(contrast));
     }
 }
 
 void PhaseStyle::polish( QApplication* app ) {
     QWindowsStyle::polish( app );
 
     qt_set_draw_menu_bar_impl((QDrawMenuBarItemImpl)&PhaseStyle::drawMenuBarItem);
 }
 
 void PhaseStyle::drawPushButtonLabel (QPushButton *button, QPainter *painter) {
     bool active = button->isOn() || button->isDown();
     QRect r = pushButtonContentsRect( button );
     QColorGroup group = button->colorGroup();
     int x, y, w, h;
     r.rect( &x, &y, &w, &h );
     bool sunken = false;
     QIconSet::Mode mode;
     QPixmap pixmap;
 
     if (active)  {// shift contents
         x++; y++;
         sunken = true;
     }
 
 
     if (button->isMenuButton()) { // draw the indicator
         //dx = pixelMetric(PM_MenuButtonIndicator, widget);
         int dx = menuButtonIndicatorWidth( button->height() );
         drawArrow(painter, Qt::DownArrow, active,
                   x+w-dx, y+2, dx-4, h-4, group,button->isEnabled() );
         w -= dx;
     }
 
     if (button->iconSet() && !button->iconSet()->isNull()) { // draw icon
         if (button->isEnabled()) {
             if (button->hasFocus()) {
                 mode = QIconSet::Active;
             } else {
                 mode = QIconSet::Normal;
             }
         } else {
             mode = QIconSet::Disabled;
         }
 
 #if 0
         if (button->isToggleButton() && button->isOn()) {
             state = true;
         } else {
             state = false;
         }
 #endif
 
         pixmap = button->iconSet()->pixmap(QIconSet::Small, mode);
         if (button->text().isEmpty() && !button->pixmap()) {
             painter->drawPixmap(x+w/2 - pixmap.width()/2,
                                 y+h/2 - pixmap.height()/2, pixmap);
         } else {
             painter->drawPixmap(x+4, y+h/2 - pixmap.height()/2, pixmap);
         }
         x += pixmap.width() + 4;
         w -= pixmap.width() + 4;
     }
 
     if (active || button->isDefault()) { // default button
         for(int n=0; n<2; n++) {
             drawItem(painter, x+n, y, w, h,
                      AlignCenter | ShowPrefix,
                      button->colorGroup(),
                      button->isEnabled(),
                      button->pixmap(),
                      button->text(), -1,
                      (button->isEnabled()) ?
                      &button->colorGroup().buttonText() :
                      &button->colorGroup().mid());
         }
     } else { // normal button
         drawItem(painter, x, y, w, h,
                  AlignCenter | ShowPrefix,
                  button->colorGroup(),
                  button->isEnabled(),
                  button->pixmap(),
                  button->text(), -1,
                  (button->isEnabled()) ?
                  &button->colorGroup().buttonText() :
                  &button->colorGroup().mid());
     }
 }
 
 
 void PhaseStyle::drawFocusRect(QPainter *painter, const QRect &rect,
                                const QColorGroup &group,
                                const QColor *, bool atBorder) {
 
 
     QPen old = painter->pen();
     painter->setPen(group.highlight().dark(contrast));
     painter->setBrush(NoBrush);
 
     if ( atBorder )
         painter->drawRect(QRect(rect.x()+1,     rect.y()+1,
                                 rect.width()-2, rect.height()-2 ));
     else
         painter->drawRect(rect);
 
 
     painter->setPen(old);
 
 }
 
 void PhaseStyle::drawSeperator( QPainter* painter, int x, int y, int w,
                                 int h, const QColorGroup& group,  bool,
                                 int , int  ) {
     qWarning( "Seperator" );
     QRect rect(x, y, w, h);
     int x2 = rect.right();
     int y2 = rect.bottom();
 
     painter->setPen(group.dark());
     if (w < h)
         painter->drawLine(w/2, y, w/2, y2);
     else
         painter->drawLine(x, h/2, x2, h/2);
 }
 
 void PhaseStyle::drawMenuBarItem(QPainter* p, int x, int y, int w, int h,
                          QMenuItem *mi, QColorGroup& g, bool enabled,
                          bool act ) {
     return QWindowsStyle::drawMenuBarItem(p, x, y, w, h, mi, g, enabled, act);
 }
 
 
 void PhaseStyle::drawIndicator(QPainter* painter, int x, int y, int w, int h,
                                const QColorGroup &group, int state, bool,
                                bool enabled  ) {
     drawPanel(painter, x, y, w, h, group, true, 1, enabled ?
                    &group.brush(QColorGroup::Base) :
                    &group.brush(QColorGroup::Background));
 
     if (QButton::On == state ) {
         painter->setPen(group.dark());
         painter->drawRect(x+3, y+3, w-6, h-6);
         painter->fillRect(x+4, y+4, w-8, h-8,
                           group.brush(QColorGroup::Highlight));
     }
 }
 
 
 void PhaseStyle::drawExclusiveIndicator(QPainter* painter,  int x, int y, int w, int h,
                                         const QColorGroup &group, bool on,
                                         bool /*down*/, bool enabled) {
 
     QRect r(x, y, w, h );
 
 
     /*
      * As Polygon and Polyline are broken in Qt2 lets use
      * something not that spectacilur -> ellipse
      */
     painter->save();
     painter->fillRect(x, y, w, h, group.background());
 
 
     painter->setBrush(enabled
                       ? group.brush(QColorGroup::Base)
                       : group.brush(QColorGroup::Background));
     painter->setPen(group.dark());
 
     if (0 == w % 2) --w;
     if (0 == h % 2) --h;
     painter->drawEllipse(x, y, w, h );
 
     if(on) {
         painter->setBrush(group.brush(QColorGroup::Highlight));
         painter->drawEllipse(x+3,y+3,w-6,h-6);
     }
 
     painter->restore();
 }
 
 
 /*
  * Does not get called in QWS as it seems
  */
 void PhaseStyle::drawExclusiveIndicatorMask(QPainter *painter, int x, int y, int w,
                                             int h, bool /*on*/ ) {
     return;
 
 
 
     if (0 != w%2) --w;
     if (0 != h%2) --h;
 
     QRect r(x, y, w, h );
     int x2 = r.right();
     int y2 = r.bottom();
     int cx = (x + x2) / 2;
     int cy = (y + y2) / 2;
     QPointArray parray;
 
 
     painter->setBrush(Qt::color1);
     painter->setPen(Qt::color1);
     parray.putPoints(0, 8,
                      x,cy+1, x,cy,    cx,y,    cx+1,y,
                      x2,cy,  x2,cy+1, cx+1,y2, cx,y2);
     painter->drawPolygon(parray, 0, 8);
 }
 
 int PhaseStyle::defaultFrameWidth()const {
     return 1;
 }
 
 int PhaseStyle::popupMenuItemHeight ( bool ,
                                       QMenuItem * mi,
                                       const QFontMetrics & fm ) {
     int h = 0;
     if (mi->custom() ) {
         h = mi->custom()->sizeHint().height();
         if (!mi->custom()->fullSpan() )
             h += ITEMVMARGIN*2 + ITEMFRAME*2;
     }else if (mi->isSeparator() ) {
         h = 1;
     }else {
         if ( mi->pixmap() ) {
             h = QMAX(h, mi->pixmap()->height() + ITEMFRAME*2);
         }else {
             h = QMAX(h, MINICONSIZE+ITEMFRAME*2 );
             h = QMAX(h, fm.height()
                      + ITEMVMARGIN*2 + ITEMFRAME*2 );
         }
         if ( mi->iconSet() )
             h = QMAX(h, mi->iconSet()->
                      pixmap(QIconSet::Small, QIconSet::Normal ).height()
                      + ITEMFRAME*2 );
     }
 
 
     return h;
 }
 
 int PhaseStyle::extraPopupMenuItemWidth(bool checkable, int maxpmw,
                                         QMenuItem* mi, const QFontMetrics& ) {
     int w = 0;
     if (mi->isSeparator() )
         return 3;
 
     else if ( mi->pixmap() )
         w = mi->pixmap()->width();
 
     if (!mi->text().isNull() &&
         mi->text().find('\t' ) >= 0 )
         w += 12;
     else if ( mi->popup() )
         w += 2*ARROWMARGIN;
 
     if ( maxpmw  )
         w += maxpmw +4;
 
 
     if (  maxpmw > 0 || checkable )
         w += ITEMHMARGIN*2+8;
 
     w += RIGHTBORDER;
     return w;
 }
 
 QSize PhaseStyle::indicatorSize()const {
     return QSize( 11, 11 );
 }
 
 QSize PhaseStyle::exclusiveIndicatorSize()const {
     return QSize( 11, 11 );
 }
 
 void PhaseStyle::getButtonShift( int &x, int &y ) {
     x++;
     y++;
 }
 
 void PhaseStyle::drawPopupMenuItem ( QPainter * p, bool checkable,
                                      int maxpmw,int tabwidth,
                                      QMenuItem * mi, const QPalette & pal,
                                      bool act, bool enabled, int x,
                                      int y, int w, int h ) {
     if ( !mi )
         return;
 
     QRect rect(x, y, w, h );
     int x2, y2;
     x2 = rect.right();
     y2 = rect.bottom();
     const QColorGroup& g = pal.active();
     QColorGroup itemg    = !enabled ? pal.disabled() : pal.active();
 
     if ( checkable || maxpmw ) maxpmw = QMAX(maxpmw, 20);
 
     if (act && enabled )
         p->fillRect(x, y, w, h, g.highlight() );
     else
         p->fillRect(x, y, w, h, g.background() );
 
     // draw seperator
     if (mi->isSeparator() ) {
         p->setPen( g.dark() );
         p->drawLine( x+8, y+1, x+w-8, y+1 );
 
         p->setPen( g.mid() );
         p->drawLine( x+8,   y, x+w-8, y );
         p->drawPoint(x+w,y+1);
 
         p->setPen( g.midlight() );
         p->drawLine( x+8, y-1, x+w-8, y-1 );
         p->drawPoint(x+8, y );
         return;
     }
 
     // draw icon
     QIconSet::Mode mode;
     if ( mi->iconSet() && !mi->isChecked() ) {
         if ( act )
             mode = enabled ? QIconSet::Active : QIconSet::Disabled;
         else
             mode = enabled ? QIconSet::Normal : QIconSet::Disabled;
         QPixmap pixmap = mi->iconSet()->pixmap(QIconSet::Small, mode );
         QRect pmrect(0, 0, pixmap.width(), pixmap.height() );
         QRect cr(x, y, maxpmw, h );
         pmrect.moveCenter( cr.center() );
         p->drawPixmap(pmrect.topLeft(), pixmap);
     }
 
     // draw check
     if(mi->isChecked() ) {
         drawCheckMark(p, x, y, maxpmw, h, itemg, act, !enabled );
     }
 
 
     // draw text
     int xm = maxpmw + 2;
     int xp = x + xm;
     int tw = w -xm - 2;
 
     p->setPen( enabled ? ( act ? g.highlightedText() : g.buttonText() ) :
                          g.mid() );
 
 
     if ( mi->custom() ) {
         p->save();
         mi->custom()->paint(p, g, act, enabled,
                               xp, y+1, tw, h-2 );
         p->restore();
     }else { // draw label
         QString text = mi->text();
         if (!text.isNull() ) {
             int t = text.find('\t');
             const int tflags = AlignVCenter | DontClip |
                                ShowPrefix |  SingleLine |
                                AlignLeft;
 
             if (t >= 0) {
                 int tabx = x + w - tabwidth - RIGHTBORDER -
                            ITEMHMARGIN - ITEMFRAME;
                 p->drawText(tabx, y+ITEMVMARGIN, tabwidth,
                             h-2*ITEMVMARGIN, tflags,
                             text.mid(t+1) );
                 text = text.left(t );
             }
 
             // draw left label
              p->drawText(xp, y+ITEMVMARGIN,
                          tw, h-2*ITEMVMARGIN,
                          tflags, text, t);
         }else if ( mi->pixmap() ) { // pixmap as label
             QPixmap pixmap = *mi->pixmap();
             if ( pixmap.depth() == 1 )
                 p->setBackgroundMode( OpaqueMode );
 
             int dx = ((w-pixmap.width() )  /2 ) +
                  ((w - pixmap.width()) %2 );
             p->drawPixmap(x+dx, y+ITEMFRAME, pixmap );
 
             if ( pixmap.depth() == 1 )
                 p->setBackgroundMode( TransparentMode );
         }
     }
 
     if ( mi->popup() ) { // draw submenu arrow
         int dim = (h-2*ITEMFRAME) / 2;
         drawArrow( p, RightArrow, false,
                    x+w-ARROWMARGIN-ITEMFRAME-dim,
                    y+h/2-dim/2, dim, dim, g, enabled );
     }
 }
 
 
 QRect PhaseStyle::comboButtonRect ( int x, int y, int w, int h ) {
     return QRect(x+2, y+2, w-4-17, h-5 );
 }
 
 void PhaseStyle::drawComboButton( QPainter * p, int x, int y,
                                   int w, int h,
                                   const QColorGroup & g,
                                   bool sunken,
                                   bool editable,
                                   bool,
                                   const QBrush *) {
     drawButton(p, x, y, w, h, g,
                sunken, &g.brush(QColorGroup::Button ));
 
+    for ( int n = 0; n < 2; ++n )
+        kColorBitmaps(p, g, w-16+(6*n), y+(h/2)-2,
+                      0, &doodad_mid, &doodad_light, 0, 0, 0 );
 
-    bool odd = (h % 2);
-    drawPanel(p, w-15 , y+(h/2)-3,  10, (odd ? 7 : 6 ),
-              g, true , 1, sunken ? &g.brush(QColorGroup::Midlight)
-              : &g.brush(QColorGroup::Mid) );
 
     if (editable ) {
         const int x2 = x+w-1; const int y2 = y+h-1;
         p->setPen(g.dark());
         p->drawLine(x2+1, y, x2+1, y2);
         p->setPen(g.midlight());
         p->drawLine(x2+2, y, x2+2, y2-1);
         p->setPen(g.button());
         p->drawPoint(x2+2, y2);
     }
 
     p->setPen(g.buttonText() );
 }
 
 
 void PhaseStyle::drawTab(QPainter* painter, const QTabBar* bar, QTab* tab,
                          bool selected ) {
     bool edge = false;
     int x, y, w, h;
     QRect r = tab->rect();
     r.rect(&x,&y,&w,&h);
     const int x2 = x+w-1;
     const int y2 = y+h-1;
     const QColorGroup &group = bar->colorGroup();
 
 
     painter->save();
 
     // what position is the tab?
     if ((bar->count() == 1 ))
         edge = true;
     else
         edge = false;
 
     switch (QTabBar::Shape(bar->shape())) {
     case QTabBar::RoundedAbove:
     case QTabBar::TriangularAbove: {
         if (!selected) { // shorten
             y += 2; h -= 2;
         }
         if (selected) {
             painter->setPen(Qt::NoPen);
             painter->fillRect(x+1, y+1, w-1, h-1,
                               group.brush(QColorGroup::Background));
         } else
             drawPhaseGradient(painter, QRect(x+1, y+1, w-1, h-2),
                               group.background().dark(contrast) );
 
 
         // draw tab
         painter->setPen(group.dark());
         painter->drawLine(x, y, x, y2-2);
         painter->drawLine(x+1, y, x2, y);
         painter->drawLine(x2, y+1, x2, y2-2);
 
         painter->setPen(group.mid());
         painter->drawLine(x2-1, y+2, x2-1, y2-2);
 
         painter->setPen(group.midlight());
         painter->drawLine(x+1, y+1, x2-2, y+1);
         if ((selected) || edge) painter->drawLine(x+1, y+2, x+1, y2-2);
 
         // finish off bottom
         if (selected) {
             painter->setPen(group.dark());
             painter->drawPoint(x, y2-1);
             painter->drawPoint(x2, y2-1);
 
             painter->setPen(group.midlight());
             painter->drawPoint(x, y2);
             painter->drawLine(x+1, y2-1, x+1, y2);
             painter->drawPoint(x2, y2);
 
             painter->setPen(group.mid());
             painter->drawPoint(x2-1, y2-1);
 
             if (edge) {
                 painter->setPen(group.dark());
                 painter->drawLine(x, y2-1, x, y2);
                 painter->setPen(group.midlight());
                 painter->drawPoint(x+1, y2);
             }
         } else {
             painter->setPen(group.dark());
             painter->drawLine(x, y2-1, x2, y2-1);
 
             painter->setPen(group.midlight());
             painter->drawLine(x, y2, x2, y2);
 
             if (edge) {
                 painter->setPen(group.dark());
                 painter->drawLine(x, y2-1, x, y2);
             }
         }
         break;
     }
     case QTabBar::RoundedBelow:
     case QTabBar::TriangularBelow: {
         painter->setBrush( group.background().dark(contrast));
         painter->setPen(Qt::NoPen);
         painter->fillRect(x+1, y+1, w-1, h-1, painter->brush());
 
         // draw tab
         painter->setPen(group.dark());
         painter->drawLine(x, y+1, x, y2);
         painter->drawLine(x+1, y2, x2, y2);
         painter->drawLine(x2, y+1, x2, y2-1);
 
         painter->setPen(group.mid());
         painter->drawLine(x2-1, y+1, x2-1, y2-1);
         painter->drawLine(x+2, y2-1, x2-1, y2-1);
         painter->drawPoint(x, y);
         painter->drawPoint(x2, y);
 
         if ((selected) || edge) {
             painter->setPen(group.midlight());
             painter->drawLine(x+1, y+1, x+1, y2-2);
         }
 
         // finish off top
         if (selected) {
             if (edge) {
                 painter->setPen(group.dark());
                 painter->drawPoint(x, y);
                 painter->setPen(group.midlight());
                 painter->drawPoint(x+1, y);
             }
         } else {
             painter->setPen(group.dark());
             painter->drawLine(x, y+1, x2, y+1);
 
             painter->setPen(group.mid());
             painter->drawLine(x, y, x2, y);
 
             if (edge) {
                 painter->setPen(group.dark());
                 painter->drawPoint(x, y);
             }
         }
           break;
     }
     }
 
     painter->restore();
 }
 
 void PhaseStyle::drawTabMask( QPainter* p, const QTabBar*, QTab* tab,
                               bool ) {
     p->fillRect(tab->rect(), Qt::color1);
 }
 
 void PhaseStyle::drawToolButton(QPainter * p, int x, int y,
                                 int w, int h, const QColorGroup & g,
                                 bool sunken,
                                 const QBrush * fill ) {
     QRect r(x, y, w, h );
     p->fillRect(r, g.background());
 
     drawPanel(p, x, y, w, h, g, sunken, 1,
               fill ? fill : &g.brush(QColorGroup::Button) );
 
 
     p->setPen(g.text() );
 }
 
 
 /*
  * LGPLv2  Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
  *
  * ../web/webstyle.cpp
  */
 void PhaseStyle::scrollBarMetrics(const QScrollBar* sb, int& sliderMin,
                                   int& sliderMax, int &sliderLength,
                                   int& buttonDim ) {
     int maxlen;
     bool horizontal = sb->orientation() == QScrollBar::Horizontal;
     int len = (horizontal) ? sb->width() : sb->height();
     int extent = (horizontal) ? sb->height() : sb->width();
 
     if (len > (extent - 1) * 2)
         buttonDim = extent;
     else
         buttonDim = len / 2 - 1;
 
     if (horizontal)
         sliderMin = buttonDim * 2;
     else
         sliderMin = 1;
 
     maxlen = len - buttonDim * 2 - 1;
     int div = QMAX(1, (sb->maxValue() - sb->minValue() + sb->pageStep() ) );
 
     sliderLength =
         (sb->pageStep() * maxlen) / div;
 
     if (sliderLength < SCROLLBAR_EXTENT)
         sliderLength = SCROLLBAR_EXTENT;
 
     if (sliderLength > maxlen)
         sliderLength = maxlen;
 
     sliderMax = sliderMin + maxlen - sliderLength;
 }
 
 void PhaseStyle::drawScrollBarControls( QPainter* p, const QScrollBar *sb,
                                         int sliderStart, uint controls,
                                         uint activeControl) {
     const bool horizontal = (sb->orientation() == Qt::Horizontal );
     int sliderMin, sliderMax, sliderLength, buttonDim;
     const QColorGroup& g = sb->colorGroup();
     QRect sub, add, subPage, addPage, slider;
     int x, y, x2, y2;
 
     scrollBarMetrics( sb, sliderMin, sliderMax, sliderLength, buttonDim );
 
     /* lets get the positions */
     scrollBarItemPositions(sb, horizontal, sliderStart,
                            sliderMax, sliderLength, buttonDim,
                            sub, add, subPage, addPage,
                            slider );
 
 
     /* sanity */
     if ( sliderStart > sliderMax )
         sliderStart = sliderMax;
 
     // addline
     if ( controls & AddLine && add.isValid() ) {
         x =  add.x();     y  = add.y();
         x2 = add.width(); y2 = add.height();
         const bool down = (activeControl & AddLine );
         drawBevelButton(p, x, y, x2, y2, g, down,
                         &g.brush(QColorGroup::Button));
 
         Qt::ArrowType arrow = horizontal ? RightArrow : DownArrow;
         if (down ) {
             switch (arrow ) {
             case DownArrow:   y++; break;
             case RightArrow:  x++; break;
             default:               break;
             }
         }
         drawArrow( p, arrow, down, x, y, x2, y2, g, true );
     }
 
     if ( controls & SubLine && sub.isValid() ) {
         x =  sub.x();     y  = sub.y();
         x2 = sub.width(); y2 = sub.height();
         const bool down = (activeControl & SubLine );
         drawBevelButton(p, x, y, x2, y2, g, down,
                         &g.brush(QColorGroup::Button));
 
         Qt::ArrowType arrow = horizontal ? LeftArrow : UpArrow;
         if (down ) {
             switch (arrow ) {
             case UpArrow:   y--; break;
             case LeftArrow: x--; break;
             default:             break;
             }
         }
         drawArrow( p, arrow, down, x, y, x2, y2, g, true );
     }
 
     if ( controls & AddPage && addPage.isValid()  ) {
         x  = addPage.x();     y  = addPage.y();
         x2 = addPage.right(); y2 = addPage.bottom();
 
         p->fillRect(addPage, g.mid());
         p->setPen(g.dark());
         if (horizontal) { // vertical
             p->drawLine(x, y, x2, y);
             p->drawLine(x, y2, x2, y2);
         } else { // horizontal
             p->drawLine(x, y, x, y2);
             p->drawLine(x2, y, x2, y2);
         }
     }
 
     if ( controls & SubPage && subPage.isValid() ) {
         x  = subPage.x();     y  = subPage.y();
         x2 = subPage.right(); y2 = subPage.bottom();
 
         p->fillRect(subPage, g.mid());
         p->setPen(g.dark());
         if (horizontal) { // vertical
             p->drawLine(x, y, x2, y);
             p->drawLine(x, y2, x2, y2);
         } else { // horizontal
             p->drawLine(x, y, x, y2);
             p->drawLine(x2, y, x2, y2);
         }
 }
 
     if ( controls & Slider && slider.isValid() ) {
         x  = slider.x();     y  = slider.y();
         x2 = slider.width(); y2 = slider.height();
         const bool down = ( activeControl & Slider );
         int cx = x + x2/2 -2; int cy = y + y2/2 -2;
 
         drawBevelButton(p, x, y, x2, y2, g, down,
                         &g.brush(QColorGroup::Button) );
 
         if (horizontal && (x2 >=20)) {
             for (int n = -5; n <= 5; n += 5)
                 kColorBitmaps(p, g, cx+n, cy,
                                 0, &doodad_mid, &doodad_light, 0, 0, 0);
         } else if (!horizontal && (y2 >= 20)) {
             for (int n = -5; n <= 5; n += 5)
                 kColorBitmaps(p, g, cx, cy+n,
                               0, &doodad_mid, &doodad_light, 0, 0, 0);
         }
 
         if ( sb->hasFocus() && down ) {
             slider = QRect(slider.x()+2, slider.y()+2,
                            slider.width()-2, slider.height()-2 );
             drawFocusRect(p, slider, g, false );
         }
 
     }
 }
 
 /*
  * LGPLv2  Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
  *
  * ../web/webstyle.cpp
  */
 QStyle::ScrollControl PhaseStyle::scrollBarPointOver( const QScrollBar * sb,
                                      int sliderStart,
                                      const QPoint & point ) {
     if (!sb->rect().contains(point))
         return NoScroll;
 
     int sliderMin, sliderMax, sliderLength, buttonDim;
     scrollBarMetrics(sb, sliderMin, sliderMax, sliderLength, buttonDim);
 
     if (sb->orientation() == QScrollBar::Horizontal) {
         int x = point.x();
 
         if (x <= buttonDim)
             return SubLine;
         else if (x <= buttonDim * 2)
             return AddLine;
         else if (x < sliderStart)
             return SubPage;
         else if (x < sliderStart+sliderLength)
             return Slider;
         else
             return AddPage;
     } else   {
         int y = point.y();
 
         if (y < sliderStart)
             return SubPage;
         else if (y < sliderStart + sliderLength)
             return Slider;
         else if (y < sliderMax + sliderLength)
             return AddPage;
         else if (y < sliderMax + sliderLength + buttonDim)
             return SubLine;
         else
             return AddLine;
   }
 }
 
 /*
  * LGPLv2  Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
  *
  * ../web/webstyle.cpp
  * scrollBarControlsMetrics
  */
 void PhaseStyle::scrollBarItemPositions( const QScrollBar* sb, const bool horizontal,
                                          int sliderStart, int sliderMax,
                                          int sliderLength, int buttonDim,
                                          QRect &rSub, QRect& rAdd, QRect& rSubPage,
                                          QRect &rAddPage, QRect& rSlider ) {
 
     int len     = horizontal ? sb->width()  : sb->height();
     int extent  = horizontal ? sb->height() : sb->width();
 
     QColorGroup g = sb->colorGroup();
 
     if (sliderStart > sliderMax)
         sliderStart = sliderMax;
 
     int sliderEnd = sliderStart + sliderLength;
 
     int addX, addY;
     int subX, subY;
     int subPageX, subPageY, subPageW, subPageH;
     int addPageX, addPageY, addPageW, addPageH;
     int sliderX, sliderY, sliderW, sliderH;
 
     if (horizontal){
         subY      = 0;
         addY      = 0;
         subX      = 0;
         addX      = buttonDim;
 
         subPageX  = buttonDim * 2;
         subPageY  = 0;
         subPageW  = sliderStart - 1;
         subPageH  = extent;
 
         addPageX  = sliderEnd;
         addPageY  = 0;
         addPageW  = len - sliderEnd;
         addPageH  = extent;
 
         sliderX   = sliderStart;
         sliderY   = 0;
         sliderW   = sliderLength;
         sliderH   = extent;
     }else {
         subX    = 0;
         addX    = 0;
         subY    = len - buttonDim * 2;
         addY    = len - buttonDim;
 
         subPageX = 0;
         subPageY = 0;
         subPageW = extent;
         subPageH = sliderStart;
 
         addPageX  = 0;
         addPageY  = sliderEnd;
         addPageW  = extent;
         addPageH  = subY - sliderEnd;
 
         sliderX   = 0;
         sliderY   = sliderStart;
         sliderW   = extent;
         sliderH   = sliderLength;
     }
 
     rSub      .setRect(    subX,      subY, buttonDim, buttonDim);
     rAdd      .setRect(    addX,      addY, buttonDim, buttonDim);
     rSubPage  .setRect(subPageX,  subPageY,  subPageW,  subPageH);
     rAddPage  .setRect(addPageX,  addPageY,  addPageW,  addPageH);
     rSlider   .setRect( sliderX,   sliderY,   sliderW,   sliderH);
 
 }
 
 
 void PhaseStyle::drawSlider (QPainter * p, int x, int y,
                              int w, int h, const QColorGroup &g,
                              Orientation o, bool, bool ) {
     int cx = x + w/2;
     int cy = y + h/2;
     QBrush brush = g.brush( QColorGroup::Button );
 
     if ( o == Horizontal ) {
         drawBevelButton(p, cx-5, y, 6, h, g, false,
                         &brush );
         drawBevelButton(p, cx, y, 6, h, g, false,
                         &brush );
     }else {
         drawBevelButton(p, x, cy-5, w, 6, g, false,
                         &brush );
         drawBevelButton(p, x, cy, w, 6, g, false,
                         &brush );
     }
 }
 
 void PhaseStyle::drawSliderGroove(QPainter* p, int x, int y,
                                   int w, int h, const QColorGroup& g,
                                   QCOORD , Orientation o ) {
     int cx = x + w/2;
     int cy = y + h/2;
 
     if ( o == Horizontal ) {
         y = cy-3; h = 7;
     }else {
         x = cx-3; w = 7;
     }
 
     drawPanel(p, x, y, w, h, g, true, 1,
               &g.brush(QColorGroup::Mid ) );
 }