uiuiui - fixed a bug which let running applications crash if switched style

from phase to any other. Reason was that in phase-style a special menubaritem-
drawroutine was set but not RESET to qte default if this style was removed
I'd implemented the unPolish routine and just set this callback to 0 (qt-default)
and now it works nice.

2 files changed, 21 insertions, 9 deletions

diff --git a/noncore/styles/phase/phasestyle.cpp b/noncore/styles/phase/phasestyle.cpp
index ba8c460..906ccee 100644
--- a/noncore/styles/phase/phasestyle.cpp
+++ b/noncore/styles/phase/phasestyle.cpp
@@ -273,115 +273,125 @@ void PhaseStyle::drawBevelButton(QPainter* p, int x, int y,
 
     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 {
@@ -586,105 +596,105 @@ int PhaseStyle::extraPopupMenuItemWidth(bool checkable, int maxpmw,
     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.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->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 -
@@ -731,99 +741,99 @@ void PhaseStyle::drawComboButton( QPainter * p, int x, int y,
                                   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 );
 
 
     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::tabbarMetrics( const QTabBar* t, int &hframe, int &vframe,  int& ov ) {
     QCommonStyle::tabbarMetrics( t, hframe, vframe, ov );
     hframe -= 2;
     vframe += 1;
 }
 
 
 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;
+    edge = true;
     else
-	edge = false;
+    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);
diff --git a/noncore/styles/phase/phasestyle.h b/noncore/styles/phase/phasestyle.h
index cbaa534..ae53efe 100644
--- a/noncore/styles/phase/phasestyle.h
+++ b/noncore/styles/phase/phasestyle.h
@@ -1,93 +1,95 @@
 //////////////////////////////////////////////////////////////////////////////
 // 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.
 //////////////////////////////////////////////////////////////////////////////
 
 #ifndef PHASESTYLE_H
 #define PHASESTYLE_H
 
 #include <qstyle.h>
 #include <qwindowsstyle.h>
 #include <qcolor.h>
 
 class KPixmap;
 
 class PhaseStyle : public QWindowsStyle
 {
     Q_OBJECT
 public:
     PhaseStyle();
     virtual ~PhaseStyle();
 
-    void polish( QWidget * );
-    void polish( QPalette& );
-    void polish( QApplication* );
+    virtual void polish( QWidget * );
+    virtual void polish( QPalette& );
+    virtual void polish( QApplication* a);
+    virtual void unPolish( QWidget * );
+    virtual void unPolish(QApplication *a);
 
 
     void drawCheckMark ( QPainter * p, int x, int y, int w,
                          int h, const QColorGroup & g,
                          bool act, bool dis );
     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);
 
     void drawPushButton(QPushButton* btn, QPainter* p );
     void drawPushButtonLabel(QPushButton* btn, QPainter* p );
     void drawPanel(QPainter* p, int , int, int, int,
                    const QColorGroup&, bool sunken = false,
                    int lineWidth = 1, const QBrush  *b = 0l );
     void drawButton( QPainter*, int x, int y, int w, int h,
                      const QColorGroup&, bool sunken = false,
                      const QBrush* fill = 0);
     void drawBevelButton(QPainter*, int, int, int, int,
                          const QColorGroup&, bool sunken = false,
                          const QBrush* fill = 0 );
     void drawFocusRect( QPainter* p, const QRect& r,
                         const QColorGroup&, const QColor* = 0,
                         bool atBorder = false );
     void drawButtonMask( QPainter* p, int x, int y,
                          int w, int h );
 
 
     /* Menu Stuff */
     void drawSeperator( QPainter* p, int x, int y, int w,
                         int h, const QColorGroup& group,  bool sunken = true,
                         int lineWidth = 1, int midLineWidtth = 0 );
     void drawMenuBarItem(QPainter* p, int x, int y, int w, int h,
                          QMenuItem *mi, QColorGroup& g, bool enabled,
                          bool act);
 
     /* RadioButton, CheckBox... */
     void drawIndicator(QPainter* p, int x, int y, int w, int h,
                        const QColorGroup &g, int state, bool down = FALSE,
                        bool enabled = TRUE );
     void drawExclusiveIndicator( QPainter*, int, int, int, int,
                                  const QColorGroup&, bool on,
                                  bool down = false,bool enabled = true );
     void drawExclusiveIndicatorMask (QPainter*, int, int, int, int, bool );
 
     /* spacing,dimensions */
     int defaultFrameWidth () const;
     int popupMenuItemHeight ( bool checkable,
                               QMenuItem * mi,