- make opie compilable against qte 2.3.10 snapshot

  check QT_VERSION against 0x030000 instead of 300

5 files changed, 11 insertions, 11 deletions

diff --git a/library/lightstyle.cpp b/library/lightstyle.cpp
index f18bdca..3bd1623 100644
--- a/library/lightstyle.cpp
+++ b/library/lightstyle.cpp
@@ -1,562 +1,562 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "lightstyle.h"
 
-#if QT_VERSION < 300
+#if QT_VERSION < 0x030000
 
 #define INCLUDE_MENUITEM_DEF
 #include "qmenubar.h"
 #include "qapplication.h"
 #include "qpainter.h"
 #include "qpalette.h"
 #include "qframe.h"
 #include "qpushbutton.h"
 #include "qdrawutil.h"
 #include "qscrollbar.h"
 #include "qtabbar.h"
 #include "qguardedptr.h"
 #include "qlayout.h"
 #include "qlineedit.h"
 
 
 class LightStylePrivate
 {
 public:
     LightStylePrivate()
 	: hoverWidget(0), ref(1), savePalette(0)
     {
     }
 
     QGuardedPtr<QWidget> hoverWidget;
     QPalette oldPalette, hoverPalette;
     int ref;
     QPoint mousePos;
     QPalette *savePalette;
 };
 
 
 static LightStylePrivate *singleton = 0;
 
 
 LightStyle::LightStyle()
     : QWindowsStyle()
 {
     if (! singleton) {
 	singleton = new LightStylePrivate;
 
 	QPalette pal = QApplication::palette();
 	singleton->oldPalette = pal;
 
 	QColor bg = pal.color(QPalette::Active, QColorGroup::Background);
 	QColor prelight;
 
 	if ( (bg.red() + bg.green() + bg.blue()) / 3 > 128)
 	    prelight = pal.color(QPalette::Active,
 				 QColorGroup::Background).light(110);
 	else
 	    prelight = pal.color(QPalette::Active,
 				 QColorGroup::Background).light(120);
 
 	QColorGroup active2(pal.color(QPalette::Active,
 				      QColorGroup::Foreground),      // foreground
 			    prelight,                                // button
 			    prelight.light(),                        // light
 			    prelight.dark(),                         // dark
 			    prelight.dark(120),                      // mid
 			    pal.color(QPalette::Active,
 				      QColorGroup::Text),            // text
 			    pal.color(QPalette::Active,
 				      QColorGroup::BrightText),      // bright text
 			    pal.color(QPalette::Active,
 				      QColorGroup::Base),            // base
 			    bg);                                     // background
 	active2.setColor(QColorGroup::Highlight,
 			 pal.color(QPalette::Active, QColorGroup::Highlight));
 
 	singleton->hoverPalette = pal;
 	singleton->hoverPalette.setActive(active2);
  	singleton->hoverPalette.setInactive(active2);
     } else
 	singleton->ref++;
 }
 
 
 LightStyle::~LightStyle()
 {
     if (singleton && singleton->ref-- <= 0) {
 	delete singleton;
 	singleton = 0;
     }
 }
 
 
 QSize LightStyle::scrollBarExtent() const
 {
     return QSize(12 + defaultFrameWidth(), 12 + defaultFrameWidth());
 }
 
 
 int LightStyle::buttonDefaultIndicatorWidth() const
 {
     return 2;
 }
 
 
 int LightStyle::sliderThickness() const
 {
     return 16;
 }
 
 int LightStyle::sliderLength() const
 {
     return 13;
 }
 
 
 int LightStyle::buttonMargin() const
 {
     return 4;
 }
 
 
 QSize LightStyle::exclusiveIndicatorSize() const
 {
     return QSize(13, 13);
 }
 
 
 int LightStyle::defaultFrameWidth() const
 {
     return 2;
 }
 
 
 QSize LightStyle::indicatorSize() const
 {
     return QSize(13, 13);
 }
 
 
 void LightStyle::polish(QWidget *widget)
 {
     if (widget->inherits("QPushButton"))
 	widget->installEventFilter(this);
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     if (widget->inherits("QLineEdit")) {
 	QLineEdit *lineedit = (QLineEdit *) widget;
 	lineedit->setFrameShape(QFrame::StyledPanel);
 	lineedit->setLineWidth(2);
     }
 #endif
 
     QWindowsStyle::polish(widget);
 }
 
 
 void LightStyle::unPolish(QWidget *widget)
 {
     if (widget->inherits("QPushButton"))
 	widget->removeEventFilter(this);
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     if (widget->inherits("QLineEdit")) {
 	QLineEdit *lineedit = (QLineEdit *) widget;
 	lineedit->setLineWidth(1);
 	lineedit->setFrameShape(QFrame::WinPanel);
     }
 #endif
 
     QWindowsStyle::unPolish(widget);
 }
 
 
 void LightStyle::polish(QApplication *app)
 {
     QPalette pal = app->palette();
 
     QColorGroup active(pal.color(QPalette::Active,
 				 QColorGroup::Foreground),           // foreground
 		       pal.color(QPalette::Active,
 				 QColorGroup::Button),               // button
 		       pal.color(QPalette::Active,
 				 QColorGroup::Background).light(),   // light
 		       pal.color(QPalette::Active,
 				 QColorGroup::Background).dark(175), // dark
 		       pal.color(QPalette::Active,
 				 QColorGroup::Background).dark(110), // mid
 		       pal.color(QPalette::Active,
 				 QColorGroup::Text),                 // text
 		       pal.color(QPalette::Active,
 				 QColorGroup::BrightText),           // bright text
 		       pal.color(QPalette::Active,
 				 QColorGroup::Base),                 // base
 		       pal.color(QPalette::Active,
 				 QColorGroup::Background)),          // background
 
 
 	disabled(pal.color(QPalette::Disabled,
 			   QColorGroup::Foreground),                 // foreground
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Button),                     // button
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Background).light(),         // light
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Background).dark(),          // dark
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Background).dark(110),       // mid
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Text),                       // text
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::BrightText),                 // bright text
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Base),                       // base
 		 pal.color(QPalette::Disabled,
 			   QColorGroup::Background));                // background
 
     active.setColor(QColorGroup::Highlight,
 		    pal.color(QPalette::Active, QColorGroup::Highlight));
     disabled.setColor(QColorGroup::Highlight,
 		      pal.color(QPalette::Disabled, QColorGroup::Highlight));
 
     active.setColor(QColorGroup::HighlightedText,
 		    pal.color(QPalette::Active, QColorGroup::HighlightedText));
     disabled.setColor(QColorGroup::HighlightedText,
 		      pal.color(QPalette::Disabled, QColorGroup::HighlightedText));
 
     pal.setActive(active);
     pal.setInactive(active);
     pal.setDisabled(disabled);
 
     singleton->oldPalette = pal;
 
     QColor bg = pal.color(QPalette::Active, QColorGroup::Background);
     QColor prelight;
 
     if ( (bg.red() + bg.green() + bg.blue()) / 3 > 128)
 	prelight = pal.color(QPalette::Active,
 			     QColorGroup::Background).light(110);
     else
 	prelight = pal.color(QPalette::Active,
 			     QColorGroup::Background).light(120);
 
     QColorGroup active2(pal.color(QPalette::Active,
 				  QColorGroup::Foreground),      // foreground
 			prelight,                                // button
 			prelight.light(),                        // light
 			prelight.dark(),                         // dark
 			prelight.dark(120),                      // mid
 			pal.color(QPalette::Active,
 				  QColorGroup::Text),            // text
 			pal.color(QPalette::Active,
 				  QColorGroup::BrightText),      // bright text
 			pal.color(QPalette::Active,
 				  QColorGroup::Base),            // base
 			bg);                                     // background
     active2.setColor(QColorGroup::Highlight,
 		     pal.color(QPalette::Active, QColorGroup::Highlight));
 
     singleton->hoverPalette = pal;
     singleton->hoverPalette.setActive(active2);
     singleton->hoverPalette.setInactive(active2);
 
     app->setPalette(pal);
 }
 
 
 void LightStyle::unPolish(QApplication *app)
 {
     app->setPalette(singleton->oldPalette);
 }
 
 
 void LightStyle::polishPopupMenu(QPopupMenu *menu)
 {
     menu->setMouseTracking(TRUE);
 }
 
 
 void LightStyle::drawPushButton(QPushButton *button, QPainter *p)
 {
     int x1, y1, x2, y2;
     button->rect().coords(&x1, &y1, &x2, &y2);
 
     if (button->isDefault()) {
 	p->save();
 	p->setPen(button->palette().active().color(QColorGroup::Highlight));
 	p->setBrush(button->palette().active().brush(QColorGroup::Highlight));
 	p->drawRoundRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1, 15, 15);
 	p->restore();
     }
 
     if (button->isDefault() || button->autoDefault()) {
         x1 += buttonDefaultIndicatorWidth();
         y1 += buttonDefaultIndicatorWidth();
         x2 -= buttonDefaultIndicatorWidth();
         y2 -= buttonDefaultIndicatorWidth();
 
 	if (button->isDefault()) {
 	    QPointArray pa(8);
 	    pa.setPoint(0, x1 + 2, y1    );
 	    pa.setPoint(1, x2 - 1, y1    );
 	    pa.setPoint(2, x2 + 1, y1 + 2);
 	    pa.setPoint(3, x2 + 1, y2 - 2);
 	    pa.setPoint(4, x2 - 2, y2 + 1);
 	    pa.setPoint(5, x1 + 2, y2 + 1);
 	    pa.setPoint(6, x1,     y2 - 1);
 	    pa.setPoint(7, x1,     y1 + 2);
 	    QRegion r(pa);
 	    p->setClipRegion(r);
 	}
     }
 
     QBrush fill;
     if (button->isDown() || button->isOn())
         fill = button->colorGroup().brush(QColorGroup::Mid);
     else
         fill = button->colorGroup().brush(QColorGroup::Button);
 
     if ( !button->isFlat() || button->isOn() || button->isDown() )
         drawButton(p, x1, y1, x2 - x1 + 1, y2 - y1 + 1,
                    button->colorGroup(), button->isOn() || button->isDown(), &fill);
 }
 
 
 void LightStyle::drawButton(QPainter *p, int x, int y, int w, int h,
                                  const QColorGroup &g,
                                  bool sunken, const QBrush *fill)
 {
     p->save();
     if ( fill )
 	p->fillRect(x + 2, y + 2, w - 4, h - 4, *fill);
     else
 	p->fillRect(x + 2, y + 2, w - 4, h - 4,
 		    QBrush(sunken ? g.mid() : g.button()));
 
     // frame
     p->setPen(g.dark());
     p->drawLine(x, y + 2, x, y + h - 3); // left
     p->drawLine(x + 2, y, x + w - 3, y); // top
     p->drawLine(x + w - 1, y + 2, x + w - 1, y + h - 3); // right
     p->drawLine(x + 2, y + h - 1, x + w - 3, y + h - 1); // bottom
     p->drawPoint(x + 1, y + 1);
     p->drawPoint(x + 1, y + h - 2);
     p->drawPoint(x + w - 2, y + 1);
     p->drawPoint(x + w - 2, y + h - 2);
 
     // bevel
     if (sunken)
 	p->setPen(g.mid());
     else
 	p->setPen(g.light());
 
     p->drawLine(x + 1, y + 2, x + 1, y + h - 3); // left
     p->drawLine(x + 2, y + 1, x + w - 3, y + 1); // top
 
     if (sunken)
 	p->setPen(g.light());
     else
 	p->setPen(g.mid());
 
     p->drawLine(x + w - 2, y + 2, x + w - 2, y + h - 3); // right + 1
     p->drawLine(x + 2, y + h - 2, x + w - 3, y + h - 2); // bottom + 1
 
     p->restore();
 }
 
 
 void LightStyle::drawBevelButton(QPainter *p, int x, int y, int w, int h,
                                       const QColorGroup &g,
                                       bool sunken, const QBrush *fill)
 {
     drawButton(p, x, y, w, h, g, sunken, fill);
 }
 
 
 void LightStyle::getButtonShift(int &x, int &y) const
 {
     x = y = 0;
 }
 
 
 void LightStyle::drawComboButton(QPainter *p, int x, int y, int w, int h,
 			       const QColorGroup &g, bool,
 			       bool editable, bool,
 			       const QBrush *fill)
 {
     drawButton(p, x, y, w, h, g, FALSE, fill);
 
     if (editable) {
         QRect r = comboButtonRect(x, y, w, h);
         qDrawShadePanel(p, r.x() - 1, r.y() - 1,
 			r.width() + defaultFrameWidth(),
 			r.height() + defaultFrameWidth(),
 			g, TRUE);
     }
 
     int indent = ((y + h) / 2) - 3;
     int xpos = x;
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     if( QApplication::reverseLayout() )
         xpos += indent;
     else
 #endif
         xpos += w - indent - 5;
 
     drawArrow(p, Qt::DownArrow, TRUE, xpos, indent, 5, 5, g, TRUE, fill);
 }
 
 
 QRect LightStyle::comboButtonRect( int x, int y, int w, int h ) const
 {
     QRect r(x + 3, y + 3, w - 6, h - 6);
     int indent = ((y + h) / 2) - 3;
     r.setRight(r.right() - indent - 10);
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     if( QApplication::reverseLayout() )
         r.moveBy( indent + 10, 0 );
 #endif
 
     return r;
 }
 
 
 QRect LightStyle::comboButtonFocusRect(int x, int y, int w, int h ) const
 {
     return comboButtonRect(x, y, w, h);
 }
 
 
 void LightStyle::drawPanel(QPainter *p, int x, int y, int w, int h,
 			 const QColorGroup &g, bool sunken,
 			 int lw, const QBrush *fill)
 {
     if (lw >= 2) {
 	if ( fill )
 	    p->fillRect(x + 2, y + 2, w - 4, h - 4, *fill);
 
 	QPen oldpen = p->pen();
 
 	// frame
 	p->setPen(g.dark());
 	p->drawLine(x, y + 2, x, y + h - 3); // left
 	p->drawLine(x + 2, y, x + w - 3, y); // top
 	p->drawLine(x + w - 1, y + 2, x + w - 1, y + h - 3); // right
 	p->drawLine(x + 2, y + h - 1, x + w - 3, y + h - 1); // bottom
 	p->drawPoint(x + 1, y + 1);
 	p->drawPoint(x + 1, y + h - 2);
 	p->drawPoint(x + w - 2, y + 1);
 	p->drawPoint(x + w - 2, y + h - 2);
 
 	// bevel
 	if (sunken)
 	    p->setPen(g.mid());
 	else
 	    p->setPen(g.light());
 
 	p->drawLine(x + 1, y + 2, x + 1, y + h - 3); // left
 	p->drawLine(x + 2, y + 1, x + w - 3, y + 1); // top
 
 	if (sunken)
 	    p->setPen(g.light());
 	else
 	    p->setPen(g.mid());
 
 	p->drawLine(x + w - 2, y + 2, x + w - 2, y + h - 3); // right + 1
 	p->drawLine(x + 2, y + h - 2, x + w - 3, y + h - 2); // bottom + 1
 
 	// corners
 	p->setPen(g.background());
 	p->drawLine(x, y, x + 1, y);
 	p->drawLine(x, y + h - 1, x + 1, y + h - 1);
 	p->drawLine(x + w - 2, y, x + w - 1, y);
 	p->drawLine(x + w - 2, y + h - 1, x + w - 1, y + h - 1);
 	p->drawPoint(x, y + 1);
 	p->drawPoint(x, y + h - 2);
 	p->drawPoint(x + w - 1, y + 1);
 	p->drawPoint(x + w - 1, y + h - 2);
 
 	p->setPen(oldpen);
     } else
 	qDrawShadePanel(p, x, y, w, h, g, sunken, lw, fill);
 }
 
 
 void LightStyle::drawIndicator(QPainter *p, int x, int y ,int w, int h,
                                const QColorGroup &g, int state,
                                bool down, bool)
 {
     drawButton(p, x, y, w, h, g, TRUE,
 	       &g.brush(down ? QColorGroup::Mid : QColorGroup::Base));
 
     p->save();
 
     p->setPen(g.foreground());
     if (state == QButton::NoChange) {
 	p->drawLine(x + 3, y + h / 2, x + w - 4, y + h / 2);
 	p->drawLine(x + 3, y + 1 + h / 2, x + w - 4, y + 1 + h / 2);
 	p->drawLine(x + 3, y - 1 + h / 2, x + w - 4, y - 1 + h / 2);
     } else if (state == QButton::On) {
 	p->drawLine(x + 4, y + 3, x + w - 4, y + h - 5);
 	p->drawLine(x + 3, y + 3, x + w - 4, y + h - 4);
 	p->drawLine(x + 3, y + 4, x + w - 5, y + h - 4);
 	p->drawLine(x + 3, y + h - 5, x + w - 5, y + 3);
 	p->drawLine(x + 3, y + h - 4, x + w - 4, y + 3);
 	p->drawLine(x + 4, y + h - 4, x + w - 4, y + 4);
     }
 
     p->restore();
 }
 
 
 void LightStyle::drawExclusiveIndicator(QPainter *p, int x, int y, int w, int h,
 					const QColorGroup &g, bool on,
 					bool down, bool)
 {
     p->save();
 
     p->fillRect(x, y, w, h, g.brush(QColorGroup::Background));
 
     p->setPen(g.dark());
     p->drawArc(x, y, w, h, 0, 16*360);
     p->setPen(g.mid());
     p->drawArc(x + 1, y + 1, w - 2, h - 2, 45*16, 180*16);
     p->setPen(g.light());
     p->drawArc(x + 1, y + 1, w - 2, h - 2, 235*16, 180*16);
 
     p->setPen(down ? g.mid() : g.base());
     p->setBrush(down ? g.mid() : g.base());
     p->drawEllipse(x + 2, y + 2, w - 4, h - 4);
 
     if (on) {
 	p->setBrush(g.foreground());
 	p->drawEllipse(x + 3, y + 3, w - x - 6, h - y - 6);
     }
 
     p->restore();
 }
 
 
 
 #if 1
 //copied from QPE style
 void LightStyle::drawTab( QPainter *p, const QTabBar *tb, QTab *t, bool selected )
diff --git a/library/lightstyle.h b/library/lightstyle.h
index c377cc2..0392957 100644
--- a/library/lightstyle.h
+++ b/library/lightstyle.h
@@ -1,120 +1,120 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef LIGHTSTYLE_H
 #define LIGHTSTYLE_H
 
 
 #ifndef QT_H
 #include <qstyle.h>
 #include <qwindowsstyle.h>
 #endif // QT_H
 
-#if QT_VERSION < 300
+#if QT_VERSION < 0x030000
 
 #ifdef QT_PLUGIN_STYLE_LIGHT
 #  define Q_EXPORT_STYLE_LIGHT
 #else
 #  define Q_EXPORT_STYLE_LIGHT Q_EXPORT
 #endif // QT_PLUGIN_STYLE_LIGHT
 
 
 class Q_EXPORT_STYLE_LIGHT LightStyle : public QWindowsStyle
 {
 public:
     LightStyle();
     virtual ~LightStyle();
 
     void polish(QWidget *widget);
     void unPolish(QWidget*widget);
 
     void polish(QApplication *app);
     void unPolish(QApplication *app);
 
     void polishPopupMenu(QPopupMenu *menu);
 
     void drawPushButton(QPushButton *button, QPainter *p);
     void drawButton(QPainter *p, int x, int y, int w, int h,
                     const QColorGroup &g, bool sunken = FALSE,
                     const QBrush *fill = 0);
     void drawBevelButton(QPainter *p, int x, int y, int w, int h,
                          const QColorGroup &g, bool sunken = FALSE,
                          const QBrush *fill = 0);
     void getButtonShift(int &x, int &y) const;
 
     void drawComboButton(QPainter *p, int x, int y, int w, int h,
                          const QColorGroup &g, bool sunken = FALSE,
                          bool editable = FALSE, bool = TRUE,
                          const QBrush *fill = 0);
     QRect comboButtonRect(int x, int y, int w, int h) const;
     QRect comboButtonFocusRect(int x, int y, int w, int h) const;
 
     void drawIndicator(QPainter *p, int x, int y ,int w, int h,
                        const QColorGroup &g, int state,
                        bool = FALSE, bool = TRUE);
     QSize indicatorSize() const;
 
     void drawExclusiveIndicator(QPainter *p, int x, int y ,int w, int h,
                                 const QColorGroup &g, bool on,
                                 bool = FALSE, bool = TRUE);
     QSize exclusiveIndicatorSize() const;
 
     void drawPanel(QPainter * p, int x, int y, int w, int h,
                    const QColorGroup &g, bool sunken = FALSE,
                    int = 1, const QBrush * = 0);
 
     void scrollBarMetrics( const QScrollBar *,
                            int &, int &, int &, int & ) const;
     void drawScrollBarControls(QPainter* p, const QScrollBar* sb,
                                int sliderStart, uint controls,
                                uint activeControl);
     QStyle::ScrollControl scrollBarPointOver(const QScrollBar *, int, const QPoint& p);
 
     void drawTab(QPainter *p, const QTabBar *tabbar, QTab *tab, bool selected);
 
     void drawSlider(QPainter *p, int x, int y, int w, int h,
                     const QColorGroup &g, Qt::Orientation orientation,
                     bool, bool);
     void drawSliderGroove(QPainter *p, int x, int y, int w, int h,
                           const QColorGroup& g, QCOORD,
 			  Qt::Orientation );
 
     void drawToolBarHandle(QPainter *, const QRect &, Qt::Orientation,
 			   bool, const QColorGroup &, bool = FALSE );
 
     QSize scrollBarExtent() const;
     int buttonDefaultIndicatorWidth() const;
     int buttonMargin() const;
     int sliderThickness() const;
     int sliderLength() const;
     int defaultFrameWidth() const;
 
     int extraPopupMenuItemWidth( bool checkable, int maxpmw, QMenuItem*, const QFontMetrics& );
     int popupMenuItemHeight( bool checkable, QMenuItem*, const QFontMetrics& );
     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);
 
 protected:
     bool eventFilter(QObject *, QEvent *);
 };
 
 #endif
 
 #endif // LIGHTSTYLE_H
diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index af00f49..1c5ced3 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -1,191 +1,191 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 */
 #define QTOPIA_INTERNAL_LANGLIST
 #include <stdlib.h>
 #include <unistd.h>
 #ifndef Q_OS_MACX
 #include <linux/limits.h> // needed for some toolchains (PATH_MAX)
 #endif
 #include <qfile.h>
 #include <qqueue.h>
 #ifdef Q_WS_QWS
 #ifndef QT_NO_COP
 #if QT_VERSION <= 231
 #define private public
 #define sendLocally processEvent
 #include "qcopenvelope_qws.h"
 #undef private
 #else
 #include "qcopenvelope_qws.h"
 #endif
 #endif
 #include <qwindowsystem_qws.h>
 #endif
 #include <qtextstream.h>
 #include <qpalette.h>
 #include <qbuffer.h>
 #include <qptrdict.h>
 #include <qregexp.h>
 #include <qdir.h>
 #include <qlabel.h>
 #include <qdialog.h>
 #include <qdragobject.h>
 #include <qtextcodec.h>
 #include <qevent.h>
 #include <qtooltip.h>
 #include <qsignal.h>
 #include <qmainwindow.h>
 #include <qwidgetlist.h>
 #include <qpixmapcache.h>
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #define QTOPIA_INTERNAL_INITAPP
 #include "qpeapplication.h"
 #include "qpestyle.h"
 #include "styleinterface.h"
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
 #include <qstylefactory.h>
 #else
 #include <qplatinumstyle.h>
 #include <qwindowsstyle.h>
 #include <qmotifstyle.h>
 #include <qmotifplusstyle.h>
 #include "lightstyle.h"
 
 #include <qpe/qlibrary.h>
 #endif
 #include "global.h"
 #include "resource.h"
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
 #include "qutfcodec.h"
 #endif
 #include "config.h"
 #include "network.h"
 #ifdef QWS
 #include "fontmanager.h"
 #include "fontdatabase.h"
 #endif
 
 #include "alarmserver.h"
 #include "applnk.h"
 #include "qpemenubar.h"
 #include "textcodecinterface.h"
 #include "imagecodecinterface.h"
 #include <qtopia/qpeglobal.h>
 
 #include <unistd.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #ifndef QT_NO_SOUND
 #include <sys/soundcard.h>
 #endif
 #include "qt_override_p.h"
 
 #include <backend/rohfeedback.h>
 
 
 static bool useBigPixmaps = 0;
 
 class HackWidget : public QWidget
 {
 public:
     bool needsOk()
     { return (getWState() & WState_Reserved1 ); }
 
     QRect normalGeometry()
     { return topData()->normalGeometry; };
 };
 
 class QPEApplicationData
 {
 public:
     QPEApplicationData ( ) :
           presstimer( 0 ), presswidget( 0 ), rightpressed( false ), kbgrabbed( false ),
           notbusysent( false ), preloaded( false ), forceshow( false ), nomaximize( false ),
           keep_running( true ), qcopQok( false ),
           fontFamily( "Vera" ), fontSize( 10 ), smallIconSize( 14 ),
           bigIconSize( 32 ), qpe_main_widget( 0 )
     {
         Config cfg( "qpe" );
         cfg.setGroup( "Appearance" );
         useBigPixmaps = cfg.readBoolEntry( "useBigPixmaps", false );
         fontFamily = cfg.readEntry( "FontFamily", "Vera" );
         fontSize = cfg.readNumEntry( "FontSize", 10 );
         smallIconSize = cfg.readNumEntry( "SmallIconSize", 14 );
         bigIconSize = cfg.readNumEntry( "BigIconSize", 32 );
 #ifdef OPIE_WITHROHFEEDBACK
         RoH = 0;
 #endif
     }
 
     int presstimer;
     QWidget* presswidget;
     QPoint presspos;
 #ifdef OPIE_WITHROHFEEDBACK
     Opie::Internal::RoHFeedback *RoH;
 #endif
 
     bool rightpressed : 1;
     bool kbgrabbed    : 1;
     bool notbusysent  : 1;
     bool preloaded    : 1;
     bool forceshow    : 1;
     bool nomaximize   : 1;
     bool keep_running : 1;
     bool qcopQok      : 1;
 
     QCString fontFamily;
     int fontSize;
     int smallIconSize;
     int bigIconSize;
 
     QString appName;
     struct QCopRec
     {
         QCopRec( const QCString &ch, const QCString &msg,
                  const QByteArray &d ) :
                 channel( ch ), message( msg ), data( d )
         { }
 
         QCString channel;
         QCString message;
         QByteArray data;
     };
     QWidget* qpe_main_widget;
         QGuardedPtr<QWidget> lastraised;
     QQueue<QCopRec> qcopq;
         QString styleName;
     QString decorationName;
 
     void enqueueQCop( const QCString &ch, const QCString &msg,
                       const QByteArray &data )
     {
         qcopq.enqueue( new QCopRec( ch, msg, data ) );
     }
     void sendQCopQ()
     {
             if (!qcopQok )
                 return;
 
         QCopRec * r;
 
            while((r=qcopq.dequeue())) {
                // remove from queue before sending...
                // event loop can come around again before getting
@@ -1718,257 +1718,257 @@ void QPEApplication::pidMessage( const QCString& msg, const QByteArray& data)
     else if ( msg == "enablePreload()" ) {
         if (d->qpe_main_widget)
             d->preloaded = TRUE;
         d->keep_running = TRUE;
         /* so next quit won't quit */
     }
     else if ( msg == "raise()" ) {
         d->keep_running = TRUE;
         d->notbusysent = FALSE;
         raiseAppropriateWindow();
         // Tell the system we're still chugging along...
         QCopEnvelope e("QPE/System", "appRaised(QString)");
         e << d->appName;
     }
     else if ( msg == "flush()" ) {
         emit flush();
         // we need to tell the desktop
         QCopEnvelope e( "QPE/Desktop", "flushDone(QString)" );
         e << d->appName;
     }
     else if ( msg == "reload()" ) {
         emit reload();
     }
     else if ( msg == "setDocument(QString)" ) {
         d->keep_running = TRUE;
         QDataStream stream( data, IO_ReadOnly );
         QString doc;
         stream >> doc;
         QWidget *mw = mainWidget();
         if ( !mw )
             mw = d->qpe_main_widget;
         if ( mw )
             Global::setDocument( mw, doc );
 
     } else if ( msg == "QPEProcessQCop()" ) {
             processQCopFile();
             d->sendQCopQ();
         }else
         {
             bool p = d->keep_running;
             d->keep_running = FALSE;
             emit appMessage( msg, data);
             if ( d->keep_running ) {
                 d->notbusysent = FALSE;
                 raiseAppropriateWindow();
                 if ( !p ) {
                     // Tell the system we're still chugging along...
 #ifndef QT_NO_COP
                     QCopEnvelope e("QPE/System", "appRaised(QString)");
                     e << d->appName;
 #endif
                 }
             }
             if ( p )
                 d->keep_running = p;
     }
 #endif
 }
 
 
 /*!
   Sets widget \a mw as the mainWidget() and shows it. For small windows,
   consider passing TRUE for \a nomaximize rather than the default FALSE.
 
   \sa showMainDocumentWidget()
 */
 void QPEApplication::showMainWidget( QWidget* mw, bool nomaximize )
 {
 //        setMainWidget(mw); this breaks FastLoading because lastWindowClose() would quit
             d->show(mw, nomaximize );
 }
 
 /*!
   Sets widget \a mw as the mainWidget() and shows it. For small windows,
   consider passing TRUE for \a nomaximize rather than the default FALSE.
 
   This calls designates the application as
   a \link docwidget.html document-oriented\endlink application.
 
   The \a mw widget \e must have this slot: setDocument(const QString&).
 
   \sa showMainWidget()
 */
 void QPEApplication::showMainDocumentWidget( QWidget* mw, bool nomaximize )
 {
     if ( mw && argc() == 2 )
         Global::setDocument( mw, QString::fromUtf8(argv()[1]) );
 
 
 //    setMainWidget(mw); see above
     d->show(mw, nomaximize );
 }
 
 
 /*!
   If an application is started via a \link qcop.html QCop\endlink
   message, the application will process the \link qcop.html
   QCop\endlink message and then quit. If the application calls this
   function while processing a \link qcop.html QCop\endlink message,
   after processing its outstanding \link qcop.html QCop\endlink
   messages the application will start 'properly' and show itself.
 
   \sa keepRunning()
 */
 void QPEApplication::setKeepRunning()
 {
     if ( qApp && qApp->inherits( "QPEApplication" ) ) {
         QPEApplication * qpeApp = ( QPEApplication* ) qApp;
         qpeApp->d->keep_running = TRUE;
     }
 }
 
 /*!
   Returns TRUE if the application will quit after processing the
   current list of qcop messages; otherwise returns FALSE.
 
   \sa setKeepRunning()
 */
 bool QPEApplication::keepRunning() const
 {
     return d->keep_running;
 }
 
 /*!
   \internal
 */
 void QPEApplication::internalSetStyle( const QString &style )
 {
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     if ( style == "QPE" ) {
         setStyle( new QPEStyle );
     }
     else {
         QStyle *s = QStyleFactory::create( style );
         if ( s )
             setStyle( s );
     }
 #else
     if ( style == "Windows" ) {
         setStyle( new QWindowsStyle );
     }
     else if ( style == "QPE" ) {
         setStyle( new QPEStyle );
     }
     else if ( style == "Light" ) {
         setStyle( new LightStyle );
     }
 #ifndef QT_NO_STYLE_PLATINUM
     else if ( style == "Platinum" ) {
         setStyle( new QPlatinumStyle );
     }
 #endif
 #ifndef QT_NO_STYLE_MOTIF
     else if ( style == "Motif" ) {
         setStyle( new QMotifStyle );
     }
 #endif
 #ifndef QT_NO_STYLE_MOTIFPLUS
     else if ( style == "MotifPlus" ) {
         setStyle( new QMotifPlusStyle );
     }
 #endif
 
     else {
         QStyle *sty = 0;
         QString path = QPEApplication::qpeDir ( ) + "plugins/styles/";
 
 #ifdef Q_OS_MACX
         if ( style. find ( ".dylib" ) > 0 )
             path += style;
         else
             path = path + "lib" + style. lower ( ) + ".dylib"; // compatibility
 #else
         if ( style. find ( ".so" ) > 0 )
             path += style;
         else
             path = path + "lib" + style. lower ( ) + ".so"; // compatibility
 #endif
         static QLibrary *lastlib = 0;
         static StyleInterface *lastiface = 0;
 
         QLibrary *lib = new QLibrary ( path );
         StyleInterface *iface = 0;
 
         if (( lib-> queryInterface ( IID_Style, ( QUnknownInterface ** ) &iface ) == QS_OK ) && iface )
             sty = iface-> style ( );
 
         if ( sty ) {
             setStyle ( sty );
 
             if ( lastiface )
                 lastiface-> release ( );
             lastiface = iface;
 
             if ( lastlib ) {
                 lastlib-> unload ( );
                 delete lastlib;
             }
             lastlib = lib;
         }
         else {
             if ( iface )
                 iface-> release ( );
             delete lib;
 
             setStyle ( new LightStyle ( ));
         }
     }
 #endif
 }
 
 /*!
   \internal
 */
 void QPEApplication::prepareForTermination( bool willrestart )
 {
     if ( willrestart ) {
         QLabel *lblWait = new QLabel( tr( "Please wait..." ), 0, "wait hack", QWidget::WStyle_Customize |
                                       QWidget::WStyle_NoBorder | QWidget::WStyle_Tool );
         lblWait->setAlignment( QWidget::AlignCenter );
         lblWait->show();
         lblWait->showMaximized();
     }
     { QCopEnvelope envelope( "QPE/System", "forceQuit()" );
     }
     processEvents(); // ensure the message goes out.
 }
 
 /*!
   \internal
 */
 void QPEApplication::shutdown()
 {
     // Implement in server's QPEApplication subclass
 }
 
 /*!
   \internal
 */
 void QPEApplication::restart()
 {
     // Implement in server's QPEApplication subclass
 }
 
 static QPtrDict<void>* stylusDict = 0;
 static void createDict()
 {
     if ( !stylusDict )
         stylusDict = new QPtrDict<void>;
 }
 
 /*!
   Returns the current StylusMode for widget \a w.
 
   \sa setStylusOperation() StylusMode
 */
 QPEApplication::StylusMode QPEApplication::stylusOperation( QWidget* w )
diff --git a/library/qpestyle.cpp b/library/qpestyle.cpp
index b61ada4..0566f6b 100644
--- a/library/qpestyle.cpp
+++ b/library/qpestyle.cpp
@@ -1,154 +1,154 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qpestyle.h"
 
 
 #define QCOORDARRLEN(x) sizeof(x)/(sizeof(QCOORD)*2)
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
 
 #include <qdrawutil.h>
 #include <qcombobox.h>
 #include <qtabbar.h>
 
 QPEStyle::QPEStyle()
 {
 }
 
 QPEStyle::~QPEStyle()
 {
 }
 
 void QPEStyle::drawPrimitive( PrimitiveElement pe, QPainter *p, const QRect &r,
 			      const QColorGroup &cg, SFlags flags, const QStyleOption &data) const
 {
     switch ( pe ) {
     case PE_ButtonTool:
 	{
 	    QColorGroup mycg = cg;
 	    if ( flags & Style_On ) {
 		QBrush fill( cg.mid(), Dense4Pattern );
 		mycg.setBrush( QColorGroup::Button, fill );
 	    }
 	    drawPrimitive( PE_ButtonBevel, p, r, mycg, flags, data );
 	    break;
 	}
     case PE_ButtonCommand:
     case PE_ButtonDefault:
     case PE_ButtonBevel:
     case PE_HeaderSection:
 	{
 	    QPen oldPen = p->pen();
 	    p->fillRect( r.x()+1, r.y()+1, r.width()-2, r.height()-2, cg.brush(QColorGroup::Button) );
 
 	    int x2 = r.right();
 	    int y2 = r.bottom();
 
 	    if ( flags & (Style_Sunken | Style_Down | Style_On) )
 		p->setPen( cg.dark() );
 	    else
 		p->setPen( cg.light() );
 	    p->drawLine( r.x(), r.y()+1, r.x(), y2-1 );
 	    p->drawLine( r.x()+1, r.y(), x2-1, r.y() );
 
 	    if ( flags & (Style_Sunken | Style_Down | Style_On) )
 		p->setPen( cg.light() );
 	    else
 		p->setPen( cg.dark() );
 	    p->drawLine( x2, r.y()+1, x2, y2-1 );
 	    p->drawLine( r.x()+1, y2, x2-1, y2 );
 	    p->setPen( oldPen );
 	    break;
 	}
     case PE_FocusRect:
 	break;
     case PE_Indicator:
 	{
 	    QColorGroup mycg( cg );
 	    QBrush fill;
 	    if ( flags & Style_Down )
 		fill = cg.brush( QColorGroup::Button );
 	    else
 		fill = cg.brush( (flags&Style_Enabled) ? QColorGroup::Base : QColorGroup::Background );
 	    mycg.setBrush( QColorGroup::Button, fill );
 	    if ( flags&Style_Enabled )
 		flags |= Style_Sunken;
 	    drawPrimitive( PE_ButtonBevel, p, r, mycg, flags );
 	    if ( flags & Style_On ) {
 		QPointArray a( 7*2 );
 		int i, xx, yy;
 		xx = r.x()+3;
 		yy = r.y()+5;
 		for ( i=0; i<3; i++ ) {
 		    a.setPoint( 2*i,   xx, yy );
 		    a.setPoint( 2*i+1, xx, yy+2 );
 		    xx++; yy++;
 		}
 		yy -= 2;
 		for ( i=3; i<7; i++ ) {
 		    a.setPoint( 2*i,   xx, yy );
 		    a.setPoint( 2*i+1, xx, yy+2 );
 		    xx++; yy--;
 		}
 		if ( flags & Style_NoChange ) {
 		    p->setPen( mycg.dark() );
 		} else {
 		    p->setPen( mycg.text() );
 		}
 		p->drawLineSegments( a );
 	    }
 	    break;
 	}
     case PE_ExclusiveIndicator:
 	{
 	    static const QCOORD pts1[] = {              // dark lines
 		1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };
 	    static const QCOORD pts4[] = {              // white lines
 		2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7,
 		11,4, 10,3, 10,2 };
 	    static const QCOORD pts5[] = {              // inner fill
 		4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 };
 
 	    int x, y, w, h;
 	    r.rect( &x, &y, &w, &h );
 	    p->eraseRect( x, y, w, h );
 	    QPointArray a( QCOORDARRLEN(pts1), pts1 );
 	    a.translate( x, y );
 	    p->setPen( cg.dark() );
 	    p->drawPolyline( a );
 	    a.setPoints( QCOORDARRLEN(pts4), pts4 );
 	    a.translate( x, y );
 	    p->setPen( cg.light() );
 	    p->drawPolyline( a );
 	    a.setPoints( QCOORDARRLEN(pts5), pts5 );
 	    a.translate( x, y );
 	    QColor fillColor = ( flags&Style_Down || !(flags&Style_Enabled) ) ? cg.button() : cg.base();
 	    p->setPen( fillColor );
 	    p->setBrush( fillColor  ) ;
 	    p->drawPolygon( a );
 	    if ( flags&Style_On ) {
 		p->setPen( NoPen );
 		p->setBrush( cg.text() );
 		p->drawRect( x+5, y+4, 2, 4 );
 		p->drawRect( x+4, y+5, 4, 2 );
 	    }
 	    break;
 	}
@@ -304,257 +304,257 @@ void QPEStyle::drawComplexControl( ComplexControl control, QPainter *p,
 		QStyle::visualRect( querySubControlMetrics( CC_ComboBox, widget,
 							    SC_ComboBoxArrow ), widget );
 
 	    if ( subActive == SC_ComboBoxArrow ) {
 		p->setPen( cg.dark() );
 		p->setBrush( cg.brush( QColorGroup::Button ) );
 		p->drawRect( ar );
 	    }
 
 	    ar.addCoords( 2, 2, -2, -2 );
 	    if ( widget->isEnabled() )
 		flags |= Style_Enabled;
 
 	    if ( subActive & Style_Sunken ) {
 		flags |= Style_Sunken;
 	    }
 	    drawPrimitive( PE_ArrowDown, p, ar, cg, flags );
 	}
 
 	if ( sub & SC_ComboBoxEditField ) {
 	    const QComboBox * cb = (const QComboBox *) widget;
 	    QRect re =
 		QStyle::visualRect( querySubControlMetrics( CC_ComboBox, widget,
 							    SC_ComboBoxEditField ), widget );
 	    if ( cb->hasFocus() && !cb->editable() )
 		p->fillRect( re.x(), re.y(), re.width(), re.height(),
 			     cg.brush( QColorGroup::Highlight ) );
 
 	    if ( cb->hasFocus() ) {
 		p->setPen( cg.highlightedText() );
 		p->setBackgroundColor( cg.highlight() );
 
 	    } else {
 		p->setPen( cg.text() );
 		p->setBackgroundColor( cg.background() );
 	    }
 
 	    if ( cb->hasFocus() && !cb->editable() ) {
 		QRect re =
 		    QStyle::visualRect( subRect( SR_ComboBoxFocusRect, cb ), widget );
 		drawPrimitive( PE_FocusRect, p, re, cg, Style_FocusAtBorder, QStyleOption(cg.highlight()));
 	    }
 	}
 	break;
     default:
 	QWindowsStyle::drawComplexControl( control, p, widget, r, cg, how,
 					   sub, subActive, data );
 	break;
     }
 }
 
 int QPEStyle::pixelMetric( PixelMetric metric, const QWidget *widget ) const
 {
     int ret;
     switch( metric ) {
 	case PM_ButtonMargin:
 	    ret = 2;
 	    break;
 	case PM_DefaultFrameWidth:
 	    ret = 1;
 	    break;
 	case PM_ButtonDefaultIndicator:
 	    ret = 2;
 	    break;
 	case PM_ButtonShiftHorizontal:
 	case PM_ButtonShiftVertical:
 	    ret = -1;
 	    break;
 	case PM_IndicatorWidth:
 	    ret = 15;
 	    break;
 	case PM_IndicatorHeight:
 	    ret = 13;
 	    break;
 	case PM_ExclusiveIndicatorHeight:
 	case PM_ExclusiveIndicatorWidth:
 	    ret = 15;
 	    break;
 	case PM_ScrollBarExtent:
 	    ret = 13;
 	    break;
 	case PM_SliderLength:
 	    ret = 12;
 	    break;
 	default:
 	    ret = QWindowsStyle::pixelMetric( metric, widget );
 	    break;
     }
     return ret;
 }
 
 QSize QPEStyle::sizeFromContents( ContentsType contents, const QWidget *widget,
 				const QSize &contentsSize, const QStyleOption &data) const
 {
     QSize sz(contentsSize);
 
     switch ( contents ) {
     case CT_PopupMenuItem:
 	{
 	    if ( !widget || data.isDefault() )
 		break;
 	    sz = QWindowsStyle::sizeFromContents( contents, widget, contentsSize, data );
 	    sz = QSize( sz.width(), sz.height()-2 );
 	    break;
 	}
     default:
 	sz = QWindowsStyle::sizeFromContents( contents, widget, contentsSize, data );
 	break;
     }
 
     return sz;
 }
 
 #else
 
 #include <qfontmetrics.h>
 #include <qpalette.h>
 #include <qdrawutil.h>
 #include <qscrollbar.h>
 #include <qbutton.h>
 #include <qframe.h>
 #include <qtabbar.h>
 
 #define INCLUDE_MENUITEM_DEF
 #include <qmenudata.h>
 
 QPEStyle::QPEStyle()
 {
-#if QT_VERSION < 300
+#if QT_VERSION < 0x030000
     setButtonMargin(buttonMargin());
     setScrollBarExtent(scrollBarExtent().width(),scrollBarExtent().height());
 #endif
 }
 
 QPEStyle::~QPEStyle()
 {
 }
 
 int QPEStyle::buttonMargin() const
 {
     return 2;
 }
 
 QSize QPEStyle::scrollBarExtent() const
 {
     return QSize(13,13);
 }
 
 void QPEStyle::polish ( QPalette & )
 {
 }
 
 void QPEStyle::polish( QWidget *w )
 {
     if ( w->inherits( "QListBox" ) ||
 	 w->inherits( "QListView" ) ||
 	 w->inherits( "QPopupMenu" ) ||
 	 w->inherits( "QSpinBox" ) ) {
 	QFrame *f = (QFrame *)w;
 	f->setFrameShape( QFrame::StyledPanel );
 	f->setLineWidth( 1 );
     }
 }
 
 void QPEStyle::unPolish( QWidget *w )
 {
     if ( w->inherits( "QListBox" ) ||
 	 w->inherits( "QListView" ) ||
 	 w->inherits( "QPopupMenu" ) ||
 	 w->inherits( "QSpinBox" ) ) {
 	QFrame *f = (QFrame *)w;
 	f->setFrameShape( QFrame::StyledPanel );
 	f->setLineWidth( 2 );
     }
 }
 
 int QPEStyle::defaultFrameWidth() const
 {
     return 1;
 }
 
 void QPEStyle::drawPanel ( QPainter * p, int x, int y, int w, int h,
 			    const QColorGroup &g, bool sunken, int lineWidth, const QBrush * fill )
 {
     qDrawShadePanel( p, QRect(x, y, w, h), g, sunken, lineWidth, fill );
 }
 
 void QPEStyle::drawButton( QPainter *p, int x, int y, int w, int h,
                                 const QColorGroup &g, bool sunken, const QBrush* fill )
 {
     QPen oldPen = p->pen();
     if ( sunken )
 	p->setPen( g.dark() );
     else
 	p->setPen( g.light() );
 
     int x2 = x+w-1;
     int y2 = y+h-1;
 
     p->drawLine( x, y, x, y2 );
     p->drawLine( x, y, x2, y );
 
     if ( sunken )
 	p->setPen( g.light() );
     else
 	p->setPen( g.dark() );
 
     p->drawLine( x2, y, x2, y2 );
     p->drawLine( x, y2, x2, y2 );
     p->setPen( oldPen );
 
     p->fillRect( x+1, y+1, w-2, h-2, fill?(*fill):g.brush(QColorGroup::Button) );
 }
 
 void QPEStyle::drawButtonMask ( QPainter * p, int x, int y, int w, int h )
 {
     p->fillRect( x, y, w, h, color1 );
 }
 
 void QPEStyle::drawBevelButton( QPainter *p, int x, int y, int w, int h,
                                 const QColorGroup &g, bool sunken, const QBrush* fill )
 {
     drawButton( p, x, y, w, h, g, sunken, fill );
 }
 
 QRect QPEStyle::comboButtonRect( int x, int y, int w, int h)
 {
     return QRect(x+1, y+1, w-2-14, h-2);
 }
 
 
 QRect QPEStyle::comboButtonFocusRect( int x, int y, int w, int h)
 {
     return QRect(x+2, y+2, w-4-14, h-4);
 }
 
 void QPEStyle::drawComboButton( QPainter *p, int x, int y, int w, int h,
 				     const QColorGroup &g, bool sunken,
 				     bool /*editable*/,
 				     bool enabled,
 				     const QBrush *fill )
 {
     drawBevelButton( p, x, y, w, h, g, FALSE, fill );
     drawBevelButton( p, x+w-14, y, 14, h, g, sunken, fill );
     drawArrow( p, QStyle::DownArrow, sunken,
 	       x+w-14+ 2, y+ 2, 14- 4, h- 4, g, enabled,
 	       &g.brush( QColorGroup::Button ) );
 
 }
 
 
 void QPEStyle::drawExclusiveIndicator ( QPainter * p, int x, int y, int w,
 	int h, const QColorGroup & g, bool on, bool down, bool enabled )
 {
     static const QCOORD pts1[] = {              // dark lines
         1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };
     static const QCOORD pts4[] = {              // white lines
diff --git a/library/qpestyle.h b/library/qpestyle.h
index 19ef346..1bde0ff 100644
--- a/library/qpestyle.h
+++ b/library/qpestyle.h
@@ -1,102 +1,102 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #ifndef QPESTYLE_H
 #define QPESTYLE_H
 
 #ifndef QT_H
 #include "qwindowsstyle.h"
 #endif // QT_H
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
 
 class Q_EXPORT QPEStyle : public QWindowsStyle
 {
 public:
     QPEStyle();
     virtual ~QPEStyle();
 
     virtual void drawPrimitive( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg, SFlags flags=Style_Default, const QStyleOption & = QStyleOption::Default) const;
     virtual void drawControl( ControlElement ce, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags how=Style_Default, const QStyleOption & = QStyleOption::Default) const;
     virtual void drawComplexControl( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags how=Style_Default, SCFlags sub=SC_All, SCFlags subActive=SC_None, const QStyleOption & = QStyleOption::Default) const;
     virtual int pixelMetric( PixelMetric metric, const QWidget *widget=0 ) const;
     virtual QSize sizeFromContents( ContentsType contents, const QWidget *widget, const QSize &contentsSize, const QStyleOption & = QStyleOption::Default) const;
 };
 
 #else
 
 class Q_EXPORT QPEStyle : public QWindowsStyle
 {
 public:
     QPEStyle();
     virtual ~QPEStyle();
     virtual void polish( QPalette &p );
     virtual void polish( QWidget *w );
     virtual void unPolish( QWidget *w );
 
     int defaultFrameWidth () const;
     void drawPanel ( QPainter * p, int x, int y, int w, int h,
 		    const QColorGroup &, bool sunken=FALSE, int lineWidth = 1, const QBrush * fill = 0 );
     void drawButton( QPainter *p, int x, int y, int w, int h,
 		    const QColorGroup &g, bool sunken, const QBrush* fill );
     void drawButtonMask ( QPainter * p, int x, int y, int w, int h );
     void drawBevelButton( QPainter *p, int x, int y, int w, int h,
 		    const QColorGroup &g, bool sunken=FALSE, const QBrush* fill=0 );
     QRect comboButtonRect( int x, int y, int w, int h);
     QRect comboButtonFocusRect( 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, bool, bool enabled,
 		    const QBrush *fill );
     void drawExclusiveIndicator ( QPainter * p, int x, int y, int w, int h,
 		    const QColorGroup & g, bool on, bool down = FALSE, bool enabled = TRUE );
     void drawIndicator ( QPainter * p, int x, int y, int w, int h,
 		    const QColorGroup & g, int state, bool down = FALSE, bool enabled = TRUE );
     void scrollBarMetrics( const QScrollBar*, int&, int&, int&, int&);
     void drawScrollBarControls( QPainter*,  const QScrollBar*, int sliderStart, uint controls, uint activeControl );
     ScrollControl scrollBarPointOver( const QScrollBar* sb, int sliderStart, const QPoint& p );
     void drawRiffles( QPainter* p,  int x, int y, int w, int h,
                           const QColorGroup &g, bool horizontal );
     int sliderLength() const;
     void drawSlider( QPainter *p, int x, int y, int w, int h,
 		    const QColorGroup &g, Orientation, bool tickAbove, bool tickBelow );
     void drawSliderMask( QPainter *p, int x, int y, int w, int h,
 		    Orientation, bool tickAbove, bool tickBelow );
     void drawSliderGrooveMask( QPainter *p, int x, int y, int w, int h,
 		    const QColorGroup& , QCOORD c, Orientation orient );
     void drawTab( QPainter *, const QTabBar *, QTab *, bool selected );
     int extraPopupMenuItemWidth( bool checkable, int maxpmw, QMenuItem*, const QFontMetrics& );
     int popupMenuItemHeight( bool checkable, QMenuItem*, const QFontMetrics& );
     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);
 
     int buttonMargin() const;
     QSize scrollBarExtent() const;
 
 private:	// Disabled copy constructor and operator=
 #if defined(Q_DISABLE_COPY)
     QPEStyle( const QPEStyle & );
     QPEStyle& operator=( const QPEStyle & );
 #endif
 };
 
 #endif
 
 #endif // QPESTYLE_H