Initial revision

9 files changed, 1651 insertions, 0 deletions

diff --git a/noncore/styles/phase/.cvsignore b/noncore/styles/phase/.cvsignore
new file mode 100644
index 0000000..c8de896
--- a/dev/null
+++ b/noncore/styles/phase/.cvsignore
@@ -0,0 +1,3 @@
+Makefile*
+*.moc
+.obj
diff --git a/noncore/styles/phase/README b/noncore/styles/phase/README
new file mode 100644
index 0000000..5dc9e9c
--- a/dev/null
+++ b/noncore/styles/phase/README
@@ -0,0 +1,47 @@
+Opie Phase is based on the style from David Johnson
+and was backported to Qt2 by Holger Hans Peter Freyther
+
+
+
+Original PHASE 0.4 README
+
+
+Phase, Version 0.x
+==================
+
+Phase is a look and feel for KDE. It is designed to be functional but not drab
+and aesthetic but not distracting. Artistic design draws upon the genius of
+earlier masters. This is particularly true for minimalistic designs. Therefore
+I cannot in good conscience claim this look to be truly original. But I have
+done my best.
+
+The Phase widget style is built as a KDE plugin, but is also useful for
+standalone Qt programs provided that the KDE libraries are installed. Please
+read the INSTALL file for installation instructions. You can activate the
+style through the KDE Control Center.
+
+Please note that Phase requires KDE 3.x and above. It will not build or run
+under earlier versions of KDE. Full functionality requires KDE 3.2 or greater.
+The Phase homepage is at <http://www.usermode.org/code.html>.
+
+=================
+
+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.
diff --git a/noncore/styles/phase/bitmaps.h b/noncore/styles/phase/bitmaps.h
new file mode 100644
index 0000000..28bc1db
--- a/dev/null
+++ b/noncore/styles/phase/bitmaps.h
@@ -0,0 +1,70 @@
+//////////////////////////////////////////////////////////////////////////////
+// bitmaps.h
+// -------------------
+// Bitmaps for Phase
+// -------------------
+// Copyright (c) 2004 David Johnson
+// Please see the phasestyle.h file for copyright and license information.
+//////////////////////////////////////////////////////////////////////////////
+
+// Note: the "light" bits are drawn with midlight color
+
+// Arrows (6x6)
+
+#include <qbitmap.h>
+
+static QBitmap uarrow;
+static unsigned char uarrow_bits[] = {
+    0x00, 0x0c, 0x1e, 0x3f, 0x3f, 0x00};
+
+static QBitmap darrow;
+static unsigned char darrow_bits[] = {
+    0x00, 0x3f, 0x3f, 0x1e, 0x0c, 0x00};
+
+static QBitmap larrow;
+static unsigned char larrow_bits[] = {
+    0x18, 0x1c, 0x1e, 0x1e, 0x1c, 0x18};
+
+static QBitmap rarrow;
+static unsigned char rarrow_bits[] = {
+    0x06, 0x0e, 0x1e, 0x1e, 0x0e, 0x06};
+
+// plus/minus "arrows"
+
+static QBitmap bplus;
+static unsigned char bplus_bits[] = {
+    0x0c, 0x0c, 0x3f, 0x3f, 0x0c, 0x0c};
+
+static QBitmap bminus;
+static unsigned char bminus_bits[] = {
+    0x00, 0x00, 0x3f, 0x3f, 0x00, 0x00};
+
+// checkmark (9x9)
+
+static QBitmap bcheck;
+static unsigned char bcheck_bits[] = {
+    0x00, 0x00, 0x80, 0x01, 0xc0, 0x01, 0xe0, 0x00, 0x73, 0x00, 0x3f, 0x00,
+    0x1e, 0x00, 0x0c, 0x00, 0x00, 0x00};
+
+// expander arrows (9x9)
+
+static QBitmap dexpand;
+static unsigned char dexpand_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0xfe, 0x00, 0x7c, 0x00, 0x38, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static QBitmap rexpand;
+static unsigned char rexpand_bits[] = {
+    0x04, 0x00, 0x0c, 0x00, 0x1c, 0x00, 0x3c, 0x00, 0x7c, 0x00, 0x3c, 0x00,
+    0x1c, 0x00, 0x0c, 0x00, 0x04, 0x00};
+
+// scrollbar doodads (4x4)
+
+static QBitmap doodad_mid;
+static unsigned char doodad_mid_bits[] = {
+    0x07, 0x01, 0x01, 0x00};
+
+static QBitmap doodad_light;
+static unsigned char doodad_light_bits[] = {
+    0x00, 0x08, 0x08, 0x0e};
+
diff --git a/noncore/styles/phase/config.in b/noncore/styles/phase/config.in
new file mode 100644
index 0000000..40949e6
--- a/dev/null
+++ b/noncore/styles/phase/config.in
@@ -0,0 +1,4 @@
+  config PHASE
+    boolean "Phase Style 0.4 port"
+    default "n"
+    depends ( LIBQPE || LIBQPE-X11 ) 
diff --git a/noncore/styles/phase/phase.pro b/noncore/styles/phase/phase.pro
new file mode 100644
index 0000000..7ec3d01
--- a/dev/null
+++ b/noncore/styles/phase/phase.pro
@@ -0,0 +1,15 @@
+TEMPLATE    =  lib
+CONFIG      = qt plugin embedded warn_on
+SOURCES     =   phasestyle.cpp \
+		plugin.cpp 
+HEADERS     =   bitmaps.h \
+		phasestyle.h \
+		plugin.h
+               
+LIBS        += -lqpe 
+INCLUDEPATH += $(OPIEDIR)/include
+DESTDIR      = $(OPIEDIR)/plugins/styles
+TARGET       = phase
+VERSION      = 0.4.0
+
+include ( $(OPIEDIR)/include.pro )
diff --git a/noncore/styles/phase/phasestyle.cpp b/noncore/styles/phase/phasestyle.cpp
new file mode 100644
index 0000000..fb6411c
--- a/dev/null
+++ b/noncore/styles/phase/phasestyle.cpp
@@ -0,0 +1,1221 @@
+//////////////////////////////////////////////////////////////////////////////
+// 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 ));
+
+
+    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 ) );
+}
diff --git a/noncore/styles/phase/phasestyle.h b/noncore/styles/phase/phasestyle.h
new file mode 100644
index 0000000..ab593e6
--- a/dev/null
+++ b/noncore/styles/phase/phasestyle.h
@@ -0,0 +1,166 @@
+//////////////////////////////////////////////////////////////////////////////
+// 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* );
+
+
+    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,
+                              const QFontMetrics & fm );
+    int extraPopupMenuItemWidth(bool checkable, int maxpmw,
+                                QMenuItem* mi, const QFontMetrics& fm );
+
+    QSize indicatorSize()const;
+    QSize exclusiveIndicatorSize()const;
+    void getButtonShift( int &x, int &y );
+
+    /* popup drawing */
+    void drawPopupMenuItem ( QPainter * p, bool checkable, int maxpmw,
+                             int tab, QMenuItem * mi,
+                             const QPalette & pal, bool act,
+                             bool enabled, int x, int y,
+                             int w, int h );
+
+    /* combo box */
+    QRect comboButtonRect ( int x, int y, int w, int h );
+    void drawComboButton( QPainter * p, int x, int y,
+                          int w, int h,
+                          const QColorGroup & g,
+                          bool sunken = FALSE,
+                          bool editable = FALSE,
+                          bool enabled = TRUE,
+                          const QBrush * fill = 0 );
+
+    /* tabbar */
+    void drawTab(QPainter*, const QTabBar*, QTab*,
+                 bool selected );
+    void drawTabMask( QPainter*, const QTabBar*, QTab*,
+                      bool );
+
+    /* tool button */
+    void drawToolButton ( QPainter * p, int x, int y,
+                          int w, int h,
+                          const QColorGroup & g,
+                          bool sunken = FALSE,
+                          const QBrush * fill = 0 );
+
+    /* scrollbar */
+    void drawScrollBarControls ( QPainter *, const QScrollBar *,
+                                 int sliderStart, uint controls,
+                                 uint activeControl );
+    void scrollBarMetrics( const QScrollBar*, int&, int&, int&, int& );
+    QStyle::ScrollControl scrollBarPointOver( const QScrollBar*,  int sliderStart,
+                                              const QPoint& );
+
+    /* slider drawing */
+    void drawSlider ( QPainter * p, int x, int y, int w, int h,
+                      const QColorGroup & g, Orientation,
+                      bool tickAbove, bool tickBelow );
+
+    void drawSliderGroove ( QPainter * p, int x, int y, int w,
+                            int h, const QColorGroup & g,
+                            QCOORD c, Orientation );
+private:
+    void drawPhaseGradient(QPainter* p,
+                           const QRect& rec,
+                           const QColor& col )const;
+    static void scrollBarItemPositions( const QScrollBar *,
+                                        const bool horizontal,
+                                        int sliderStart,
+                                        int sliderMax,
+                                        int sliderLength,
+                                        int buttomDim,
+                                        QRect& sub,
+                                        QRect& add,
+                                        QRect& subPage,
+                                        QRect& addPage,
+                                        QRect& slider );
+};
+
+
+#endif
diff --git a/noncore/styles/phase/plugin.cpp b/noncore/styles/phase/plugin.cpp
new file mode 100644
index 0000000..8396c0a
--- a/dev/null
+++ b/noncore/styles/phase/plugin.cpp
@@ -0,0 +1,71 @@
+/*
+               =.            This file is part of the OPIE Project
+             .=l.            Copyright (c)  2002 Holger Hans Peter Freyther <zecke@handhelds.org>
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; either version 2 of the License,
+     ._= =}       :          or (at your option) any later version.
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       This program is distributed in the hope that
+     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+    : ..    .:,     . . .    without even the implied warranty of
+    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           General Public License along with
+    --        :-=`           this library; see the file COPYING.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+
+*/
+
+#include "plugin.h"
+
+#include "phasestyle.h"
+
+#include <qapplication.h>
+
+PhaseStyleImpl::PhaseStyleImpl()
+    : m_style( 0l )
+{}
+
+/* Qt will delete the style */
+PhaseStyleImpl::~PhaseStyleImpl()
+{}
+
+QRESULT PhaseStyleImpl::queryInterface( const QUuid& uuid, QUnknownInterface **iface ) {
+    *iface = 0;
+
+    if ( uuid == IID_QUnknown || uuid == IID_Style)
+        *iface = this;
+    else
+        return QS_FALSE;
+
+    (*iface)->addRef();
+
+    return QS_OK;
+}
+
+QStyle* PhaseStyleImpl::style() {
+    if (!m_style )
+        m_style = new PhaseStyle();
+    return m_style;
+}
+
+QString PhaseStyleImpl::name()const {
+    return qApp->translate("PhaseStyle", "Phase", "Name of the style Phase");
+}
+
+
+Q_EXPORT_INTERFACE()
+{
+    Q_CREATE_INSTANCE( PhaseStyleImpl )
+}
+
diff --git a/noncore/styles/phase/plugin.h b/noncore/styles/phase/plugin.h
new file mode 100644
index 0000000..9340737
--- a/dev/null
+++ b/noncore/styles/phase/plugin.h
@@ -0,0 +1,54 @@
+/*
+               =.            This file is part of the OPIE Project
+             .=l.            Copyright (c)  2004 Holger Hans Peter Freyther <zecke@handhelds.org>
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; either version 2 of the License,
+     ._= =}       :          or (at your option) any later version.
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       This program is distributed in the hope that
+     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+    : ..    .:,     . . .    without even the implied warranty of
+    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           General Public License along with
+    --        :-=`           this library; see the file COPYING
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+
+*/
+
+#ifndef PHASESTYLE_PLUGIN_H
+#define PHASESTYLE_PLUGIN_H
+
+#include <qtopia/styleinterface.h>
+
+
+class PhaseStyle;
+
+/**
+ * Factory to create PhaseStyle
+ */
+class PhaseStyleImpl : public StyleInterface {
+public:
+    PhaseStyleImpl();
+    virtual ~PhaseStyleImpl();
+
+    QRESULT queryInterface( const QUuid&, QUnknownInterface** );
+    Q_REFCOUNT
+
+    virtual QStyle *style();
+    virtual QString  name()const;
+private:
+    PhaseStyle* m_style;
+};
+
+#endif