1 files changed, 1 insertions, 1 deletions

diff --git a/noncore/styles/phase/phasestyle.cpp b/noncore/styles/phase/phasestyle.cpp
index 906ccee..746354e 100644
--- a/noncore/styles/phase/phasestyle.cpp
+++ b/noncore/styles/phase/phasestyle.cpp
@@ -1,435 +1,435 @@
 //////////////////////////////////////////////////////////////////////////////
 // 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,
+        drawPanel(painter, x, y, w, h, 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::unPolish( QWidget *w )
 {
     QWindowsStyle::unPolish( w );
 }
 
 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::unPolish( QApplication* app ) {
     QWindowsStyle::unPolish(app);
     qt_set_draw_menu_bar_impl ( 0 );
 }
 
 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();