diff --git a/clients/oxygen/oxygenbutton.cpp b/clients/oxygen/oxygenbutton.cpp
index 9db5100f7..937cc102e 100644
--- a/clients/oxygen/oxygenbutton.cpp
+++ b/clients/oxygen/oxygenbutton.cpp
@@ -1,305 +1,340 @@
 //////////////////////////////////////////////////////////////////////////////
 // oxygenbutton.cpp
 // -------------------
 // Oxygen window decoration for KDE. Buttons.
 // -------------------
 // Copyright (c) 2006, 2007 Riccardo Iaconelli <riccardo@kde.org>
 // Copyright (c) 2006, 2007 Casper Boemann <cbr@boemann.dk>
 //
 // 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 "oxygenbutton.h"
+#include <kcommondecoration.h>
 
 #include <math.h>
 #include <QPainterPath>
 #include <QPainter>
 #include <QPen>
 #include <QBitmap>
 
 #include <kdecoration.h>
 #include <kglobal.h>
 #include <KColorUtils>
 #include <kdebug.h>
 #include <KColorScheme>
 
 #include "oxygenclient.h"
 #include "oxygen.h"
 
 namespace Oxygen
 {
 // class OxygenClient;
 /*
 extern int BUTTONSIZE;
 extern int DECOSIZE;*/
 
 // static const int DECOSIZE        = 8;
 //////////////////////////////////////////////////////////////////////////////
 // OxygenButton Class                                                      //
 //////////////////////////////////////////////////////////////////////////////
 
 //////////////////////////////////////////////////////////////////////////////
 // OxygenButton()
 // ---------------
 // Constructor
 
 OxygenButton::OxygenButton(OxygenClient &parent,
                              const QString& tip, ButtonType type)
     : KCommonDecorationButton((::ButtonType)type, &parent)
     , client_(parent)
     , helper_(parent.helper_)
     , type_(type)
     , lastmouse_(0)
     , colorCacheInvalid_(true)
 {
     setAutoFillBackground(false);
     setAttribute(Qt::WA_OpaquePaintEvent, false);
     setFixedSize(OXYGEN_BUTTONSIZE, OXYGEN_BUTTONSIZE);
     setCursor(Qt::ArrowCursor);
     setToolTip(tip);
 }
 
 OxygenButton::~OxygenButton()
 {
 }
 
 //declare function from oxygenclient.cpp
 QColor reduceContrast(const QColor &c0, const QColor &c1, double t);
 
 
 QColor OxygenButton::buttonDetailColor(const QPalette &palette)
 {
     if (client_.isActive())
         return palette.color(QPalette::Active, QPalette::ButtonText);
     else {
         if (colorCacheInvalid_) {
             QColor ab = palette.color(QPalette::Active, QPalette::Button);
             QColor af = palette.color(QPalette::Active, QPalette::ButtonText);
             QColor nb = palette.color(QPalette::Inactive, QPalette::Button);
             QColor nf = palette.color(QPalette::Inactive, QPalette::ButtonText);
 
             colorCacheInvalid_ = false;
             cachedButtonDetailColor_ = reduceContrast(nb, nf, qMax(qreal(2.5), KColorUtils::contrastRatio(ab, KColorUtils::mix(ab, af, 0.4))));
         }
         return cachedButtonDetailColor_;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // sizeHint()
 // ----------
 // Return size hint
 
 QSize OxygenButton::sizeHint() const
 {
     return QSize(OXYGEN_BUTTONSIZE, OXYGEN_BUTTONSIZE);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // enterEvent()
 // ------------
 // Mouse has entered the button
 
 void OxygenButton::enterEvent(QEvent *e)
 {
     KCommonDecorationButton::enterEvent(e);
     if (status_ != Oxygen::Pressed) {
         status_ = Oxygen::Hovered;
     }
     update();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // leaveEvent()
 // ------------
 // Mouse has left the button
 
 void OxygenButton::leaveEvent(QEvent *e)
 {
     KCommonDecorationButton::leaveEvent(e);
     // if we wanted to do mouseovers, we would keep track of it here
     status_ = Oxygen::Normal;
     update();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // pressSlot()
 // ------------
 // Mouse has pressed the button
 // TODO: never called?
 void OxygenButton::pressSlot()
 {
     status_ = Oxygen::Pressed;
     update();
 }
 //////////////////////////////////////////////////////////////////////////////
 // drawButton()
 // ------------
 // Draw the button
 
 void OxygenButton::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     QPalette pal = palette(); // de-const-ify
 
-
     // Set palette to the right group.
     // TODO - fix KWin to do this for us :-).
     if (client_.isActive())
         pal.setCurrentColorGroup(QPalette::Active);
     else
         pal.setCurrentColorGroup(QPalette::Inactive);
 
-//    widget->window()setPalette(pal);
-
-    helper_.renderWindowBackground(&painter, this->rect(), this, pal);
-
+    // fill the grey square
+    helper_.renderWindowBackground(&painter, this->rect(), this, pal, 0);
+    painter.setClipRect(this->rect());
+
+    // draw dividing line
+    painter.setRenderHints(QPainter::Antialiasing);
+    QRect frame = client_.widget()->rect();
+    int x = -this->geometry().x()+1;
+    int w = frame.width()-2;
+
+    const int titleHeight = client_.layoutMetric(KCommonDecoration::LM_TitleHeight);
+
+    QColor color = pal.window().color();
+    QColor light = helper_.calcLightColor( color );
+    QColor dark = helper_.calcDarkColor( color );
+
+    dark.setAlpha(120);
+
+    if(client_.isActive()) {
+        QLinearGradient lg(x,0,x+w,0);
+        lg.setColorAt(0.5, dark);
+        dark.setAlpha(0);
+        lg.setColorAt(0.0, dark);
+        lg.setColorAt(1.0, dark);
+        painter.setPen(QPen(lg,1));
+
+        painter.drawLine(QPointF(x, titleHeight-1.5),
+                                QPointF(x+w, titleHeight-1.5));
+
+        lg = QLinearGradient(x,0,x+w,0);
+        lg.setColorAt(0.5, light);
+        light.setAlpha(0);
+        lg.setColorAt(0.0, light);
+        lg.setColorAt(1.0, light);
+        painter.setPen(QPen(lg,1));
+ 
+        painter.drawLine(QPointF(x, titleHeight-0.5),
+                               QPointF(x+w, titleHeight-0.5));
+    }
+    
     if (type_ == ButtonMenu) {
         // we paint the mini icon (which is 16 pixels high)
         int dx = (width() - 16) / 2;
         int dy = (height() - 16) / 2;
         painter.drawPixmap(dx, dy, client_.icon().pixmap(16));
         return;
     }
 
 
     if(client_.maximizeMode() == OxygenClient::MaximizeRestore)
         painter.translate(0,-1);
 
     QColor bg = helper_.backgroundTopColor(pal.window());
 
-
-    QColor color = buttonDetailColor(pal);
+    color = buttonDetailColor(pal);
     if(status_ == Oxygen::Hovered || status_ == Oxygen::Pressed) {
         if(type_ == ButtonClose)
             color = KColorScheme(pal.currentColorGroup()).foreground(KColorScheme::NegativeText).color();
         else
             color = KColorScheme(pal.currentColorGroup()).decoration(KColorScheme::HoverColor).color();
 
     }
     QLinearGradient lg = helper_.decoGradient(QRect(4,4,13,13), color);
     painter.drawPixmap(0, 0, helper_.windecoButton(pal.button(), status_ == Oxygen::Pressed));
 
     if (client_.isActive()) {
         painter.setRenderHints(QPainter::Antialiasing);
         painter.setBrush(Qt::NoBrush);
         painter.setPen(QPen(lg, 2.2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
         drawIcon(&painter, pal, type_);
     }
     else {
         // outlined mode
         QPixmap pixmap(size());
         pixmap.fill(Qt::transparent);
         QPainter pp(&pixmap);
         pp.setRenderHints(QPainter::Antialiasing);
         pp.setBrush(Qt::NoBrush);
         pp.setPen(QPen(color, 3.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
         drawIcon(&pp, pal, type_);
 
         pp.setCompositionMode(QPainter::CompositionMode_DestinationOut);
         pp.setPen(QPen(color, 1.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
         drawIcon(&pp, pal, type_);
 
         painter.drawPixmap(QPoint(0,0), pixmap);
     }
 }
 
 void OxygenButton::drawIcon(QPainter *p, QPalette &pal, ButtonType &type)
 {
     switch(type)
     {
         case ButtonSticky:
             if(isChecked()) {
                 QPen newPen = p->pen();
                 newPen.setColor(KColorScheme(pal.currentColorGroup()).decoration(KColorScheme::HoverColor).color());
                 p->setPen(newPen);
             }
             p->drawPoint(QPointF(10.5,10.5));
             break;
         case ButtonHelp:
             p->translate(1.5, 1.5);
             p->drawArc(7,5,4,4,135*16, -180*16);
             p->drawArc(9,8,4,4,135*16,45*16);
             p->drawPoint(9,12);
             break;
         case ButtonMin:
             p->drawLine(QPointF( 7.5, 9.5), QPointF(10.5,12.5));
             p->drawLine(QPointF(10.5,12.5), QPointF(13.5, 9.5));
             break;
         case ButtonMax:
             switch(client_.maximizeMode())
             {
                 case OxygenClient::MaximizeRestore:
                 case OxygenClient::MaximizeVertical:
                 case OxygenClient::MaximizeHorizontal:
                     p->drawLine(QPointF( 7.5,11.5), QPointF(10.5, 8.5));
                     p->drawLine(QPointF(10.5, 8.5), QPointF(13.5,11.5));
                     break;
                 case OxygenClient::MaximizeFull:
                 {
                     p->translate(1.5, 1.5);
                     //p->setBrush(lg);
                     QPoint points[4] = {QPoint(9, 6), QPoint(12, 9), QPoint(9, 12), QPoint(6, 9)};
                     //QPoint points[4] = {QPoint(9, 5), QPoint(13, 9), QPoint(9, 13), QPoint(5, 9)};
                     p->drawPolygon(points, 4);
                     break;
                 }
             }
             break;
         case ButtonClose:
             p->drawLine(QPointF( 7.5,7.5), QPointF(13.5,13.5));
             p->drawLine(QPointF(13.5,7.5), QPointF( 7.5,13.5));
             break;
         case ButtonAbove:
             if(isChecked()) {
                 QPen newPen = p->pen();
                 newPen.setColor(KColorScheme(pal.currentColorGroup()).decoration(KColorScheme::HoverColor).color());
                 p->setPen(newPen);
             }
 
             p->drawLine(QPointF( 7.5,14), QPointF(10.5,11));
             p->drawLine(QPointF(10.5,11), QPointF(13.5,14));
             p->drawLine(QPointF( 7.5,10), QPointF(10.5, 7));
             p->drawLine(QPointF(10.5, 7), QPointF(13.5,10));
             break;
         case ButtonBelow:
             if(isChecked()) {
                 QPen newPen = p->pen();
                 newPen.setColor(KColorScheme(pal.currentColorGroup()).decoration(KColorScheme::HoverColor).color());
                 p->setPen(newPen);
             }
 
             p->drawLine(QPointF( 7.5,11), QPointF(10.5,14));
             p->drawLine(QPointF(10.5,14), QPointF(13.5,11));
             p->drawLine(QPointF( 7.5, 7), QPointF(10.5,10));
             p->drawLine(QPointF(10.5,10), QPointF(13.5, 7));
             break;
         default:
             break;
     }
 }
 
 
 
 
 
 
 
 
 } //namespace Oxygen
diff --git a/clients/oxygen/oxygenclient.cpp b/clients/oxygen/oxygenclient.cpp
index e1d593511..799491aba 100644
--- a/clients/oxygen/oxygenclient.cpp
+++ b/clients/oxygen/oxygenclient.cpp
@@ -1,458 +1,436 @@
 //////////////////////////////////////////////////////////////////////////////
 // oxygenclient.cpp
 // -------------------
 // Oxygen window decoration for KDE
 // -------------------
 // Copyright (c) 2006, 2007 Casper Boemann <cbr@boemann.dk>
 // Copyright (c) 2006, 2007 Riccardo Iaconelli <riccardo@kde.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 OXYGENCLIENT_H
 // #define OXYGENCLIENT_H
 
 #include "oxygenclient.h"
 
 #include <KConfig>
 #include <KGlobal>
 #include <KLocale>
 #include <KDebug>
 #include <KColorUtils>
 
 #include <QBitmap>
 #include <QLabel>
 #include <QLayout>
 #include <QPainter>
 #include <QToolTip>
 //Added by qt3to4:
 #include <QBoxLayout>
 #include <QGridLayout>
 #include <QResizeEvent>
 #include <QMouseEvent>
 #include <QEvent>
 #include <QShowEvent>
 #include <QPaintEvent>
 #include <QPainterPath>
 #include <QTimer>
 #include <QCache>
 
 #include "math.h"
 
 #include "oxygenclient.moc"
 #include "oxygenbutton.h"
 #include "oxygen.h"
 
 namespace Oxygen
 {
 
 K_GLOBAL_STATIC_WITH_ARGS(OxygenHelper, globalHelper, ("OxygenDeco"))
 
 void renderDot(QPainter *p, const QPointF &point, qreal diameter)
 {
     p->drawEllipse(QRectF(point.x()-diameter/2, point.y()-diameter/2, diameter, diameter));
 }
 
 
 OxygenClient::OxygenClient(KDecorationBridge *b, KDecorationFactory *f)
     : KCommonDecoration(b, f)
     , colorCacheInvalid_(true)
     , helper_(*globalHelper)
 {
 }
 
 OxygenClient::~OxygenClient()
 {
 }
 QString OxygenClient::visibleName() const
 {
     return i18n("Oxygen");
 }
 
 void OxygenClient::init()
 {
     KCommonDecoration::init();
 
     widget()->setAutoFillBackground(false);
-    widget()->setAttribute(Qt::WA_OpaquePaintEvent);
 }
 
 bool OxygenClient::decorationBehaviour(DecorationBehaviour behaviour) const
 {
     switch (behaviour) {
         case DB_MenuClose:
             return true;//Handler()->menuClose();
 
         case DB_WindowMask:
             return false;
 
         default:
             return KCommonDecoration::decorationBehaviour(behaviour);
     }
 }
 
 int OxygenClient::layoutMetric(LayoutMetric lm, bool respectWindowState, const KCommonDecorationButton *btn) const
 {
     bool maximized = maximizeMode()==MaximizeFull && !options()->moveResizeMaximizedWindows();
 
     switch (lm) {
         case LM_BorderLeft:
         case LM_BorderRight:
         case LM_BorderBottom:
         {
             if (respectWindowState && maximized) {
                 return 0;
             } else {
                 return BFRAMESIZE;
             }
         }
 
         case LM_TitleEdgeTop:
         {
             if (respectWindowState && maximized) {
                 return 0;
             } else {
                 return TFRAMESIZE;
             }
         }
 
         case LM_TitleEdgeBottom:
         {
             return 0;
         }
 
         case LM_TitleEdgeLeft:
         case LM_TitleEdgeRight:
         {
             if (respectWindowState && maximized) {
                 return 0;
             } else {
                 return 6;
             }
         }
 
         case LM_TitleBorderLeft:
         case LM_TitleBorderRight:
             return 5;
 
         case LM_ButtonWidth:
         case LM_ButtonHeight:
         case LM_TitleHeight:
         {
             if (respectWindowState && isToolWindow()) {
                 return OXYGEN_BUTTONSIZE;
             } else {
                 return OXYGEN_BUTTONSIZE;
             }
         }
 
         case LM_ButtonSpacing:
             return 1;
 
         case LM_ButtonMarginTop:
             return 0;
 
         default:
             return KCommonDecoration::layoutMetric(lm, respectWindowState, btn);
     }
 }
 
 
 KCommonDecorationButton *OxygenClient::createButton(::ButtonType type)
 {
     switch (type) {
         case MenuButton:
             return new OxygenButton(*this, i18n("Menu"), ButtonMenu);
 
         case HelpButton:
             return new OxygenButton(*this, i18n("Help"), ButtonHelp);
 
         case MinButton:
             return new OxygenButton(*this, i18n("Minimize"), ButtonMin);
 
         case MaxButton:
             return new OxygenButton(*this, i18n("Maximize"), ButtonMax);
 
         case CloseButton:
             return new OxygenButton(*this, i18n("Close"), ButtonClose);
 
         case AboveButton:
             return new OxygenButton(*this, i18n("Keep Above Others"), ButtonAbove);
 
         case BelowButton:
             return new OxygenButton(*this, i18n("Keep Below Others"), ButtonBelow);
 
         case OnAllDesktopsButton:
             return new OxygenButton(*this, i18n("On All Desktops"), ButtonSticky);
 
         default:
             return 0;
     }
 }
 
 
 // c0 - background
 // c1 - foreground
 // t - target contrast ratio
 QColor reduceContrast(const QColor &c0, const QColor &c1, double t)
 {
     double s = KColorUtils::contrastRatio(c0, c1);
     if (s < t)
         return c1;
 
     double l = 0.0, h = 1.0;
     double x = s, a;
     QColor r = c1;
     for (int maxiter = 16; maxiter; --maxiter) {
         a = 0.5 * (l + h);
         r = KColorUtils::mix(c0, c1, a);
         x = KColorUtils::contrastRatio(c0, r);
         if (fabs(x - t) < 0.01)
             break;
         if (x > t)
             h = a;
         else
             l = a;
     }
     return r;
 }
 
 
 QColor OxygenClient::titlebarTextColor(const QPalette &palette)
 {
     if (isActive())
         return palette.color(QPalette::Active, QPalette::WindowText);
     else {
         if(colorCacheInvalid_) {
             QColor ab = palette.color(QPalette::Active, QPalette::Window);
             QColor af = palette.color(QPalette::Active, QPalette::WindowText);
             QColor nb = palette.color(QPalette::Inactive, QPalette::Window);
             QColor nf = palette.color(QPalette::Inactive, QPalette::WindowText);
 
             colorCacheInvalid_ = false;
             cachedTitlebarTextColor_ = reduceContrast(nb, nf, qMax(qreal(2.5), KColorUtils::contrastRatio(ab, KColorUtils::mix(ab, af, 0.4))));
         }
         return cachedTitlebarTextColor_;
     }
 }
 
 
 void OxygenClient::paintEvent(QPaintEvent *e)
 {
     Q_UNUSED(e)
     if (!OxygenFactory::initialized()) return;
 
     QPalette palette = widget()->palette();
     QPainter painter(widget());
 
     // Set palette to the right group.
     // TODO - fix KWin to do this for us :-).
     if (isActive())
         palette.setCurrentColorGroup(QPalette::Active);
     else
         palette.setCurrentColorGroup(QPalette::Inactive);
 
     int x,y,w,h;
     QRect frame = widget()->frameGeometry();
     QColor color = palette.window().color();
     QColor light = helper_.calcLightColor( color );
     QColor dark = helper_.calcDarkColor( color );
 
     const int titleHeight = layoutMetric(LM_TitleHeight);
     const int titleTop = layoutMetric(LM_TitleEdgeTop) + frame.top();
     const int titleEdgeLeft = layoutMetric(LM_TitleEdgeLeft);
     const int marginLeft = layoutMetric(LM_TitleBorderLeft);
     const int marginRight = layoutMetric(LM_TitleBorderRight);
 
     const int titleLeft = frame.left() + titleEdgeLeft + buttonsLeftWidth() + marginLeft;
     const int titleWidth = frame.width() -
             titleEdgeLeft - layoutMetric(LM_TitleEdgeRight) -
             buttonsLeftWidth() - buttonsRightWidth() -
             marginLeft - marginRight;
 
-
-    int splitY = qMin(300, 3*frame.height()/4);
-
-    QPixmap tile = helper_.verticalGradient(color, splitY);
-    painter.drawTiledPixmap(QRect(0, 0, frame.width(), titleHeight + TFRAMESIZE), tile);
-
-    painter.drawTiledPixmap(QRect(0, 0, LFRAMESIZE, splitY), tile);
-    painter.fillRect(0, splitY, LFRAMESIZE, frame.height() - splitY, helper_.backgroundBottomColor(color));
-
-    painter.drawTiledPixmap(QRect(frame.width()-RFRAMESIZE, 0,
-                                                        RFRAMESIZE, splitY), tile,
-                                                        QPoint(frame.width()-RFRAMESIZE, 0));
-    painter.fillRect(frame.width()-RFRAMESIZE, splitY, RFRAMESIZE, frame.height() - splitY, helper_.backgroundBottomColor(color));
-
-    painter.fillRect(0, frame.height() - BFRAMESIZE, frame.width(), BFRAMESIZE, helper_.backgroundBottomColor(color));
-
-    int radialW = qMin(600, frame.width() - LFRAMESIZE - RFRAMESIZE);
-    tile = helper_.radialGradient(color, radialW);
-    // In the style we assume the top frame to have a height of 32 this we need offset here with the
-    // actual value
-    int frameTopFixer = titleTop+titleHeight - 32;
-    QRect radialRect = QRect((frame.width() - radialW) / 2, frameTopFixer, radialW, 64);
-    painter.drawPixmap(radialRect, tile);
-
+    // draw window background
+    helper_.renderWindowBackground(&painter, frame, this->widget(), palette, 0);
+    
     // draw title text
     painter.setFont(options()->font(isActive(), false));
     painter.setPen(titlebarTextColor(palette));
     painter.drawText(titleLeft, titleTop-1, titleWidth, titleHeight,  // -1 is to go into top resizearea
               OxygenFactory::titleAlign() | Qt::AlignVCenter, caption());
 
     painter.setRenderHint(QPainter::Antialiasing);
 
     // Draw dividing line
     frame = widget()->rect();
     frame.adjust(1,1,-1,-1);
     frame.getRect(&x, &y, &w, &h);
 
     dark.setAlpha(120);
 
     if(isActive()) {
         QLinearGradient lg(x,0,x+w,0);
         lg.setColorAt(0.5, dark);
         dark.setAlpha(0);
         lg.setColorAt(0.0, dark);
         lg.setColorAt(1.0, dark);
         painter.setPen(QPen(lg,1));
 
         painter.drawLine(QPointF(x, titleTop+titleHeight-1.5),
                                 QPointF(x+w, titleTop+titleHeight-1.5));
 
         lg = QLinearGradient(x,0,x+w,0);
         lg.setColorAt(0.5, light);
         light.setAlpha(0);
         lg.setColorAt(0.0, light);
         lg.setColorAt(1.0, light);
         painter.setPen(QPen(lg,1));
 
         painter.drawLine(QPointF(x, titleTop+titleHeight-0.5),
                                QPointF(x+w, titleTop+titleHeight-0.5));
     }
 
     // draw stripes as indicator for active windows
     if (isActive() && OxygenFactory::showStripes()) {
         Qt::Alignment align = OxygenFactory::titleAlign();
         if (widget()->layoutDirection() == Qt::RightToLeft)
         {
             if (align == Qt::AlignLeft)
                 align = Qt::AlignRight;
             else if (align == Qt::AlignRight)
                 align = Qt::AlignLeft;
         }
 
         if (align & Qt::AlignLeft) {
             int left = titleLeft + QFontMetrics(options()->font(isActive(), false)).width(caption());
             int right = titleLeft + titleWidth;
             drawScratch(&painter, palette, left, right, titleTop+6);
         }
         if (align & Qt::AlignRight) {
             int left = titleLeft;
             int right = titleLeft + titleWidth - QFontMetrics(options()->font(isActive(), false)).width(caption());
             drawScratch(&painter, palette, right, left, titleTop+6);
         }
         if (align & Qt::AlignHCenter) {
             int textWidth = QFontMetrics(options()->font(isActive(), false)).width(caption());
             int left = titleLeft;
             int centerLeft = titleLeft + titleWidth/2 - textWidth/2;
             int centerRight = titleLeft + titleWidth/2 + textWidth/2;
             int right = titleLeft + titleWidth;
             drawScratch(&painter, palette, centerLeft, left, titleTop+6);
             drawScratch(&painter, palette, centerRight, right, titleTop+6);
         }
     }
 
     // Draw shadows of the frame
     bool maximized = maximizeMode()==MaximizeFull && !options()->moveResizeMaximizedWindows();
 
     if(maximized)
         return;
 
     helper_.drawFloatFrame(&painter, widget()->rect(), color);
 
     if(!isResizable())
         return;
 
     // Draw the 3-dots resize handles
     qreal cenY = frame.height() / 2 + x + 0.5;
     qreal posX = frame.width() + y - 2.5;
     painter.setPen(Qt::NoPen);
     painter.setBrush(QColor(0, 0, 0, 66));
     renderDot(&painter, QPointF(posX, cenY - 3), 1.8);
     renderDot(&painter, QPointF(posX, cenY), 1.8);
     renderDot(&painter, QPointF(posX, cenY + 3), 1.8);
 
     painter.translate(x + frame.width()-9, y + frame.height()-9);
     renderDot(&painter, QPointF(2.5, 6.5), 1.8);
     renderDot(&painter, QPointF(5.5, 5.5), 1.8);
     renderDot(&painter, QPointF(6.5, 2.5), 1.8);
 }
 
 void OxygenClient::drawScratch(QPainter *p, QPalette &palette, const int start, const int end, const int topMargin)
 {
     QLinearGradient scratchlg(QPoint(start,0), QPoint(end,0));
     scratchlg.setColorAt(0.0, Qt::transparent);
     scratchlg.setColorAt(0.05, KDecoration::options()->color(ColorTitleBar));
     scratchlg.setColorAt(1.0, Qt::transparent);
     QPen pen1(scratchlg, 0.5);
 
     QLinearGradient scratchlg2(QPoint(start,0), QPoint(end,0));
     scratchlg2.setColorAt(0.0, Qt::transparent);
     scratchlg2.setColorAt(0.05, helper_.calcLightColor(palette.color(QPalette::Window)));
     scratchlg2.setColorAt(1.0, Qt::transparent);
     QPen pen2(scratchlg2, 0.5);
 
     bool antialiasing = p->testRenderHint(QPainter::Antialiasing);
     p->setRenderHint(QPainter::Antialiasing, false);
     for (int i = 0; i < 3; ++i)
     {
         p->setPen(pen1);
         p->drawLine(QPointF(start, topMargin+4*i), QPointF(end, topMargin+4*i));
         p->setPen(pen2);
         p->drawLine(QPointF(start, topMargin+4*i+1), QPointF(end, topMargin+4*i+1));
     }
     p->setRenderHint(QPainter::Antialiasing, antialiasing);
 }
 
 
 void OxygenClient::updateWindowShape()
 {
     bool maximized = maximizeMode()==MaximizeFull && !options()->moveResizeMaximizedWindows();
     int w=widget()->width();
     int h=widget()->height();
 
     if(maximized) {
         QRegion mask(0,0,w,h);
         setMask(mask);
         return;
     }
 
     QRegion mask(4, 0, w-8, h);
     mask += QRegion(0, 4, w, h-8);
     mask += QRegion(2, 1, w-4, h-2);
     mask += QRegion(1, 2, w-2, h-4);
 
     setMask(mask);
 }
 
 } //namespace Oxygen
 
 //#include "oxygenclient.moc"
 
 // #endif