20 files changed, 1037 insertions, 998 deletions
diff --git a/noncore/apps/opie-write/qrichtext_p.h b/noncore/apps/opie-write/qrichtext_p.h
index e368edb..3778feb 100644
--- a/noncore/apps/opie-write/qrichtext_p.h
+++ b/noncore/apps/opie-write/qrichtext_p.h
@@ -29,48 +29,51 @@
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** 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 QRICHTEXT_P_H
 #define QRICHTEXT_P_H
 //
 //  W A R N I N G
 //  -------------
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of a number of Qt sources files.  This header file may change from
 // version to version without notice, or even be removed.
 //
 // We mean it.
 //
 //
+#include <opie2/odebug.h>
+using namespace Opie::Core;
 #ifndef QT_H
 #include "qstring.h"
 #include "qlist.h"
 #include "qrect.h"
 #include "qfontmetrics.h"
 #include "qintdict.h"
 #include "qmap.h"
 #include "qstringlist.h"
 #include "qfont.h"
 #include "qcolor.h"
 #include "qsize.h"
 #include "qvaluelist.h"
 #include "qvaluestack.h"
 #include "qobject.h"
 #include "qdict.h"
 #include "qtextstream.h"
 #include "qpixmap.h"
 #include "qstylesheet.h"
 #include "qvector.h"
 #include "qpainter.h"
 #include "qlayout.h"
 #include "qobject.h"
 #include "qcomplextext_p.h"
 #include "qapplication.h"
@@ -103,70 +106,70 @@ public:
    // this is never called, initialize variables in QTextString::insert()!!!
    QTextStringChar() : lineStart( 0 ), type( Regular ), startOfRun( 0 ) {d.format=0;}
    ~QTextStringChar();
    QChar c;
    enum Type { Regular=0, Custom=1, Anchor=2, CustomAnchor=3 };
    uint lineStart : 1;
    uint rightToLeft : 1;
    uint hasCursor : 1;
    uint canBreak : 1;
    Type type : 2;
    uint startOfRun : 1;
    int x;
    int height() const;
    int ascent() const;
    int descent() const;
    bool isCustom() const { return (type & Custom) != 0; }
    QTextFormat *format() const;
    QTextCustomItem *customItem() const;
    void setFormat( QTextFormat *f );
    void setCustomItem( QTextCustomItem *i );
    struct CustomData
    {
-        QTextFormat *format;
+    QTextFormat *format;
-        QTextCustomItem *custom;
+    QTextCustomItem *custom;
-        QString anchorName;
+    QString anchorName;
-        QString anchorHref;
+    QString anchorHref;
    };
    void loseCustomItem();
    union {
-        QTextFormat* format;
+    QTextFormat* format;
-        CustomData* custom;
+    CustomData* custom;
    } d;
    bool isAnchor() const { return ( type & Anchor) != 0; }
    QString anchorName() const;
    QString anchorHref() const;
    void setAnchor( const QString& name, const QString& href );
 private:
    QTextStringChar &operator=( const QTextStringChar & ) {
-        //abort();
+    //abort();
-        return *this;
+    return *this;
    }
    friend class QComplexText;
    friend class QTextParagraph;
 };
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMemArray<QTextStringChar>;
 // MOC_SKIP_END
 #endif
 class Q_EXPORT QTextString
 {
 public:
    QTextString();
    QTextString( const QTextString &s );
    virtual ~QTextString();
    static QString toString( const QMemArray<QTextStringChar> &data );
    QString toString() const;
    QTextStringChar &at( int i ) const;
    int length() const;
@@ -187,56 +190,56 @@ public:
    bool isRightToLeft() const;
    QChar::Direction direction() const;
    void setDirection( QChar::Direction d ) { dir = d; bidiDirty = TRUE; }
    QMemArray<QTextStringChar> subString( int start = 0, int len = 0xFFFFFF ) const;
    QMemArray<QTextStringChar> rawData() const { return data; }
    void operator=( const QString &s ) { clear(); insert( 0, s, 0 ); }
    void operator+=( const QString &s ) {insert( length(), s, 0 ); }
    void prepend( const QString &s ) { insert( 0, s, 0 ); }
 private:
    void checkBidi() const;
    QMemArray<QTextStringChar> data;
    uint bidiDirty : 1;
    uint bidi : 1; // true when the paragraph has right to left characters
    uint rightToLeft : 1;
    uint dir : 5;
 };
 inline bool QTextString::isBidi() const
 {
    if ( bidiDirty )
-        checkBidi();
+    checkBidi();
    return bidi;
 }
 inline bool QTextString::isRightToLeft() const
 {
    if ( bidiDirty )
-        checkBidi();
+    checkBidi();
    return rightToLeft;
 }
 inline QChar::Direction QTextString::direction() const
 {
    return (QChar::Direction) dir;
 }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QValueStack<int>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QValueStack<QTextParagraph*>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QValueStack<bool>;
 // MOC_SKIP_END
 #endif
 class Q_EXPORT QTextCursor
 {
 public:
    QTextCursor( QTextDocument *d = 0 );
    QTextCursor( const QTextCursor &c );
    QTextCursor &operator=( const QTextCursor &c );
@@ -363,49 +366,49 @@ public:
    void setUndoDepth( int d ) { steps = d; }
    int undoDepth() const { return steps; }
    int historySize() const { return history.count(); }
    int currentPosition() const { return current; }
 private:
    QPtrList<QTextCommand> history;
    int current, steps;
 };
 inline QTextCommandHistory::~QTextCommandHistory()
 {
    clear();
 }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 class Q_EXPORT QTextCustomItem
 {
 public:
    QTextCustomItem( QTextDocument *p )
-        :  xpos(0), ypos(-1), width(-1), height(0), parent( p )
+    :  xpos(0), ypos(-1), width(-1), height(0), parent( p )
    {}
    virtual ~QTextCustomItem();
    virtual void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected ) = 0;
    virtual void adjustToPainter( QPainter* );
    enum Placement { PlaceInline = 0, PlaceLeft, PlaceRight };
    virtual Placement placement() const;
    bool placeInline() { return placement() == PlaceInline; }
    virtual bool ownLine() const;
    virtual void resize( int nwidth );
    virtual void invalidate();
    virtual int ascent() const { return height; }
    virtual bool isNested() const;
    virtual int minimumWidth() const;
    virtual QString richText() const;
    int xpos; // used for floating items
    int ypos; // used for floating items
    int width;
    int height;
@@ -417,74 +420,74 @@ public:
    virtual bool next( QTextCursor *, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    virtual bool prev( QTextCursor *, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    virtual bool down( QTextCursor *, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    virtual bool up( QTextCursor *, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    void setParagraph( QTextParagraph *p ) { parag = p; }
    QTextParagraph *paragraph() const { return parag; }
    QTextDocument *parent;
    QTextParagraph *parag;
    virtual void pageBreak( int  y, QTextFlow* flow );
 };
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<QString, QString>;
 // MOC_SKIP_END
 #endif
 class Q_EXPORT QTextImage : public QTextCustomItem
 {
 public:
    QTextImage( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
-                QMimeSourceFactory &factory );
+        QMimeSourceFactory &factory );
    virtual ~QTextImage();
    Placement placement() const { return place; }
    void adjustToPainter( QPainter* );
    int minimumWidth() const { return width; }
    QString richText() const;
    void draw( QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
 private:
    QRegion* reg;
    QPixmap pm;
    Placement place;
    int tmpwidth, tmpheight;
    QMap<QString, QString> attributes;
    QString imgId;
 };
 class Q_EXPORT QTextHorizontalLine : public QTextCustomItem
 {
 public:
    QTextHorizontalLine( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
-                         QMimeSourceFactory &factory );
+             QMimeSourceFactory &factory );
    virtual ~QTextHorizontalLine();
    void adjustToPainter( QPainter* );
    void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
    QString richText() const;
    bool ownLine() const { return TRUE; }
 private:
    int tmpheight;
    QColor color;
 };
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList<QTextCustomItem>;
 // MOC_SKIP_END
 #endif
 class Q_EXPORT QTextFlow
 {
    friend class QTextDocument;
    friend class QTextTableCell;
@@ -511,53 +514,53 @@ public:
    virtual bool isEmpty();
    void clear();
 private:
    int w;
    int pagesize;
    QPtrList<QTextCustomItem> leftItems;
    QPtrList<QTextCustomItem> rightItems;
 };
 inline int QTextFlow::width() const { return w; }
 class QTextTable;
 class Q_EXPORT QTextTableCell : public QLayoutItem
 {
    friend class QTextTable;
 public:
    QTextTableCell( QTextTable* table,
-                    int row, int column,
+            int row, int column,
-                    const QMap<QString, QString> &attr,
+            const QMap<QString, QString> &attr,
-                    const QStyleSheetItem* style,
+            const QStyleSheetItem* style,
-                    const QTextFormat& fmt, const QString& context,
+            const QTextFormat& fmt, const QString& context,
-                    QMimeSourceFactory &factory, QStyleSheet *sheet, const QString& doc );
+            QMimeSourceFactory &factory, QStyleSheet *sheet, const QString& doc );
    virtual ~QTextTableCell();
    QSize sizeHint() const ;
    QSize minimumSize() const ;
    QSize maximumSize() const ;
    QSizePolicy::ExpandData expanding() const;
    bool isEmpty() const;
    void setGeometry( const QRect& ) ;
    QRect geometry() const;
    bool hasHeightForWidth() const;
    int heightForWidth( int ) const;
    void adjustToPainter( QPainter* );
    int row() const { return row_; }
    int column() const { return col_; }
    int rowspan() const { return rowspan_; }
    int colspan() const { return colspan_; }
    int stretch() const { return stretch_; }
    QTextDocument* richText()  const { return richtext; }
    QTextTable* table() const { return parent; }
@@ -585,49 +588,49 @@ private:
    int cached_width;
    int cached_sizehint;
    QMap<QString, QString> attributes;
    int align;
 };
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList<QTextTableCell>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<QTextCursor*, int>;
 // MOC_SKIP_END
 #endif
 class Q_EXPORT QTextTable: public QTextCustomItem
 {
    friend class QTextTableCell;
 public:
    QTextTable( QTextDocument *p, const QMap<QString, QString> &attr );
    virtual ~QTextTable();
    void adjustToPainter( QPainter *p );
    void pageBreak( int  y, QTextFlow* flow );
    void draw( QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
-               const QColorGroup& cg, bool selected );
+           const QColorGroup& cg, bool selected );
    bool noErase() const { return TRUE; }
    bool ownLine() const { return TRUE; }
    Placement placement() const { return place; }
    bool isNested() const { return TRUE; }
    void resize( int nwidth );
    virtual void invalidate();
    virtual bool enter( QTextCursor *c, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy, bool atEnd = FALSE );
    virtual bool enterAt( QTextCursor *c, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy, const QPoint &pos );
    virtual bool next( QTextCursor *c, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    virtual bool prev( QTextCursor *c, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    virtual bool down( QTextCursor *c, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    virtual bool up( QTextCursor *c, QTextDocument *&doc, QTextParagraph *&parag, int &idx, int &ox, int &oy );
    QString richText() const;
    int minimumWidth() const;
    QPtrList<QTextTableCell> tableCells() const { return cells; }
    bool isStretching() const { return stretch; }
 private:
@@ -663,51 +666,51 @@ struct Q_EXPORT QTextDocumentSelection
    QTextCursor startCursor, endCursor;
    bool swapped;
 };
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<int, QColor>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<int, bool>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<int, QTextDocumentSelection>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList<QTextDocument>;
 // MOC_SKIP_END
 #endif
 class Q_EXPORT QTextDocument : public QObject
 {
    Q_OBJECT
    friend class QTextTableCell;
    friend class QTextCursor;
    friend class QTextEdit;
    friend class QTextParagraph;
 public:
    enum SelectionIds {
-        Standard = 0,
+    Standard = 0,
-        Temp = 32000 // This selection must not be drawn, it's used e.g. by undo/redo to
+    Temp = 32000 // This selection must not be drawn, it's used e.g. by undo/redo to
-        // remove multiple lines with removeSelectedText()
+    // remove multiple lines with removeSelectedText()
    };
    QTextDocument( QTextDocument *p );
    QTextDocument( QTextDocument *d, QTextFormatCollection *f );
    virtual ~QTextDocument();
    QTextDocument *parent() const { return par; }
    QTextParagraph *parentParagraph() const { return parentPar; }
    void setText( const QString &text, const QString &context );
    QMap<QString, QString> attributes() const { return attribs; }
    void setAttributes( const QMap<QString, QString> &attr ) { attribs = attr; }
    QString text() const;
    QString text( int parag ) const;
    QString originalText() const;
    int x() const;
    int y() const;
    int width() const;
    int widthUsed() const;
    int visibleWidth() const;
    int height() const;
    void setWidth( int w );
@@ -770,53 +773,53 @@ public:
    void setTextFormat( Qt::TextFormat f );
    Qt::TextFormat textFormat() const;
    bool inSelection( int selId, const QPoint &pos ) const;
    QStyleSheet *styleSheet() const { return sheet_; }
    QMimeSourceFactory *mimeSourceFactory() const { return factory_; }
    QString context() const { return contxt; }
    void setStyleSheet( QStyleSheet *s );
    void setDefaultFormat( const QFont &font, const QColor &color );
    void setMimeSourceFactory( QMimeSourceFactory *f ) { if ( f ) factory_ = f; }
    void setContext( const QString &c ) { if ( !c.isEmpty() ) contxt = c; }
    void setUnderlineLinks( bool b );
    bool underlineLinks() const { return underlLinks; }
    void setPaper( QBrush *brush ) { if ( backBrush ) delete backBrush; backBrush = brush; }
    QBrush *paper() const { return backBrush; }
    void doLayout( QPainter *p, int w );
    void draw( QPainter *p, const QRect& rect, const QColorGroup &cg, const QBrush *paper = 0 );
    void drawParagraph( QPainter *p, QTextParagraph *parag, int cx, int cy, int cw, int ch,
-                    QPixmap *&doubleBuffer, const QColorGroup &cg,
+            QPixmap *&doubleBuffer, const QColorGroup &cg,
-                    bool drawCursor, QTextCursor *cursor, bool resetChanged = TRUE );
+            bool drawCursor, QTextCursor *cursor, bool resetChanged = TRUE );
    QTextParagraph *draw( QPainter *p, int cx, int cy, int cw, int ch, const QColorGroup &cg,
-                      bool onlyChanged = FALSE, bool drawCursor = FALSE, QTextCursor *cursor = 0,
+              bool onlyChanged = FALSE, bool drawCursor = FALSE, QTextCursor *cursor = 0,
-                      bool resetChanged = TRUE );
+              bool resetChanged = TRUE );
    void registerCustomItem( QTextCustomItem *i, QTextParagraph *p );
    void unregisterCustomItem( QTextCustomItem *i, QTextParagraph *p );
    void setFlow( QTextFlow *f );
    void takeFlow();
    QTextFlow *flow() const { return flow_; }
    bool isPageBreakEnabled() const { return pages; }
    void setPageBreakEnabled( bool b ) { pages = b; }
    void setUseFormatCollection( bool b ) { useFC = b; }
    bool useFormatCollection() const { return useFC; }
    QTextTableCell *tableCell() const { return tc; }
    void setTableCell( QTextTableCell *c ) { tc = c; }
    void setPlainText( const QString &text );
    void setRichText( const QString &text, const QString &context );
    QString richText() const;
    QString plainText() const;
    bool focusNextPrevChild( bool next );
    int alignment() const;
@@ -837,64 +840,64 @@ public:
    void insertChild( QObject *o ) { QObject::insertChild( o ); }
    void removeChild( QObject *o ) { QObject::removeChild( o ); }
    void insertChild( QTextDocument *d ) { childList.append( d ); }
    void removeChild( QTextDocument *d ) { childList.removeRef( d ); }
    QPtrList<QTextDocument> children() const { return childList; }
    bool hasFocusParagraph() const;
    QString focusHref() const;
    void invalidateOriginalText() { oTextValid = FALSE; oText = ""; }
    static QString section( QString str, const QString &sep, int start, int end = 0xffffffff );
    static bool endsWith( QString str, const QString &s);
 signals:
    void minimumWidthChanged( int );
 private:
    void init();
    QPixmap *bufferPixmap( const QSize &s );
    // HTML parser
    bool hasPrefix(const QChar* doc, int length, int pos, QChar c);
    bool hasPrefix(const QChar* doc, int length, int pos, const QString& s);
    QTextCustomItem* parseTable( const QMap<QString, QString> &attr, const QTextFormat &fmt,
-                                 const QChar* doc, int length, int& pos, QTextParagraph *curpar );
+                 const QChar* doc, int length, int& pos, QTextParagraph *curpar );
    bool eatSpace(const QChar* doc, int length, int& pos, bool includeNbsp = FALSE );
    bool eat(const QChar* doc, int length, int& pos, QChar c);
    QString parseOpenTag(const QChar* doc, int length, int& pos, QMap<QString, QString> &attr, bool& emptyTag);
    QString parseCloseTag( const QChar* doc, int length, int& pos );
    QChar parseHTMLSpecialChar(const QChar* doc, int length, int& pos);
    QString parseWord(const QChar* doc, int length, int& pos, bool lower = TRUE);
    QChar parseChar(const QChar* doc, int length, int& pos, QStyleSheetItem::WhiteSpaceMode wsm );
    void setRichTextInternal( const QString &text, QTextCursor* cursor = 0 );
    void setRichTextMarginsInternal( QPtrList< QPtrVector<QStyleSheetItem> >& styles, QTextParagraph* stylesPar );
 private:
    struct Q_EXPORT Focus {
-        QTextParagraph *parag;
+    QTextParagraph *parag;
-        int start, len;
+    int start, len;
-        QString href;
+    QString href;
    };
    int cx, cy, cw, vw;
    QTextParagraph *fParag, *lParag;
    QTextPreProcessor *pProcessor;
    QMap<int, QColor> selectionColors;
    QMap<int, QTextDocumentSelection> selections;
    QMap<int, bool> selectionText;
    QTextCommandHistory *commandHistory;
    QTextFormatter *pFormatter;
    QTextIndent *indenter;
    QTextFormatCollection *fCollection;
    Qt::TextFormat txtFormat;
    uint preferRichText : 1;
    uint pages : 1;
    uint useFC : 1;
    uint withoutDoubleBuffer : 1;
    uint underlLinks : 1;
    uint nextDoubleBuffered : 1;
    uint oTextValid : 1;
    uint mightHaveCustomItems : 1;
    int align;
    int nSelections;
    QTextFlow *flow_;
@@ -910,72 +913,72 @@ private:
    int rightmargin;
    QTextParagraph *minwParag, *curParag;
    QStyleSheet* sheet_;
    QMimeSourceFactory* factory_;
    QString contxt;
    QMap<QString, QString> attribs;
    int *tArray;
    int tStopWidth;
    int uDepth;
    QString oText;
    QPtrList<QTextDocument> childList;
    QColor linkColor;
    double scaleFontsFactor;
    short list_tm,list_bm, list_lm, li_tm, li_bm, par_tm, par_bm;
 };
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 class Q_EXPORT QTextDeleteCommand : public QTextCommand
 {
 public:
    QTextDeleteCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
-                        const QByteArray& oldStyle );
+            const QByteArray& oldStyle );
    QTextDeleteCommand( QTextParagraph *p, int idx, const QMemArray<QTextStringChar> &str );
    virtual ~QTextDeleteCommand();
    Commands type() const { return Delete; }
    QTextCursor *execute( QTextCursor *c );
    QTextCursor *unexecute( QTextCursor *c );
 protected:
    int id, index;
    QTextParagraph *parag;
    QMemArray<QTextStringChar> text;
    QByteArray styleInformation;
 };
 class Q_EXPORT QTextInsertCommand : public QTextDeleteCommand
 {
 public:
    QTextInsertCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
-                        const QByteArray& oldStyleInfo )
+            const QByteArray& oldStyleInfo )
-        : QTextDeleteCommand( d, i, idx, str, oldStyleInfo ) {}
+    : QTextDeleteCommand( d, i, idx, str, oldStyleInfo ) {}
    QTextInsertCommand( QTextParagraph *p, int idx, const QMemArray<QTextStringChar> &str )
-        : QTextDeleteCommand( p, idx, str ) {}
+    : QTextDeleteCommand( p, idx, str ) {}
    virtual ~QTextInsertCommand() {}
    Commands type() const { return Insert; }
    QTextCursor *execute( QTextCursor *c ) { return QTextDeleteCommand::unexecute( c ); }
    QTextCursor *unexecute( QTextCursor *c ) { return QTextDeleteCommand::execute( c ); }
 };
 class Q_EXPORT QTextFormatCommand : public QTextCommand
 {
 public:
    QTextFormatCommand( QTextDocument *d, int sid, int sidx, int eid, int eidx, const QMemArray<QTextStringChar> &old, QTextFormat *f, int fl );
    virtual ~QTextFormatCommand();
    Commands type() const { return Format; }
    QTextCursor *execute( QTextCursor *c );
    QTextCursor *unexecute( QTextCursor *c );
 protected:
    int startId, startIndex, endId, endIndex;
    QTextFormat *format;
    QMemArray<QTextStringChar> oldFormats;
    int flags;
@@ -990,79 +993,79 @@ public:
    Commands type() const { return Style; }
    QTextCursor *execute( QTextCursor *c );
    QTextCursor *unexecute( QTextCursor *c );
    static QByteArray readStyleInformation(  QTextDocument* d, int fParag, int lParag );
    static void writeStyleInformation(  QTextDocument* d, int fParag, const QByteArray& style );
 private:
    int firstParag, lastParag;
    QByteArray before;
    QByteArray after;
 };
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 struct Q_EXPORT QTextParagraphSelection
 {
    int start, end;
 };
 struct Q_EXPORT QTextLineStart
 {
    QTextLineStart() : y( 0 ), baseLine( 0 ), h( 0 )
 #ifndef QT_NO_COMPLEXTEXT
-        , bidicontext( 0 )
+    , bidicontext( 0 )
 #endif
    {  }
    QTextLineStart( ushort y_, ushort bl, ushort h_ ) : y( y_ ), baseLine( bl ), h( h_ ),
-        w( 0 )
+    w( 0 )
 #ifndef QT_NO_COMPLEXTEXT
-        , bidicontext( 0 )
+    , bidicontext( 0 )
 #endif
    {  }
 #ifndef QT_NO_COMPLEXTEXT
    QTextLineStart( QBidiContext *c, QBidiStatus s ) : y(0), baseLine(0), h(0),
-        status( s ), bidicontext( c ) { if ( bidicontext ) bidicontext->ref(); }
+    status( s ), bidicontext( c ) { if ( bidicontext ) bidicontext->ref(); }
 #endif
    virtual ~QTextLineStart()
    {
 #ifndef QT_NO_COMPLEXTEXT
-        if ( bidicontext && bidicontext->deref() )
+    if ( bidicontext && bidicontext->deref() )
-            delete bidicontext;
+        delete bidicontext;
 #endif
    }
 #ifndef QT_NO_COMPLEXTEXT
    void setContext( QBidiContext *c ) {
-        if ( c == bidicontext )
+    if ( c == bidicontext )
-            return;
+        return;
-        if ( bidicontext && bidicontext->deref() )
+    if ( bidicontext && bidicontext->deref() )
-            delete bidicontext;
+        delete bidicontext;
-        bidicontext = c;
+    bidicontext = c;
-        if ( bidicontext )
+    if ( bidicontext )
-            bidicontext->ref();
+        bidicontext->ref();
    }
    QBidiContext *context() const { return bidicontext; }
 #endif
 public:
    ushort y, baseLine, h;
 #ifndef QT_NO_COMPLEXTEXT
    QBidiStatus status;
 #endif
    int w;
 private:
 #ifndef QT_NO_COMPLEXTEXT
    QBidiContext *bidicontext;
 #endif
 };
 #if defined(Q_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<int, QTextParagraphSelection>;
 Q_TEMPLATE_EXTERN template class Q_EXPORT QMap<int, QTextLineStart*>;
 // MOC_SKIP_END
 #endif
@@ -1162,49 +1165,49 @@ public:
    bool fullSelected( int id ) const;
    void setEndState( int s );
    int endState() const;
    void setParagId( int i );
    int paragId() const;
    bool firstPreProcess() const;
    void setFirstPreProcess( bool b );
    void indent( int *oldIndent = 0, int *newIndent = 0 );
    void setExtraData( QTextParagraphData *data );
    QTextParagraphData *extraData() const;
    QMap<int, QTextLineStart*> &lineStartList();
    void setFormat( int index, int len, QTextFormat *f, bool useCollection = TRUE, int flags = -1 );
    void setAlignment( int a );
    int alignment() const;
    virtual void paint( QPainter &painter, const QColorGroup &cg, QTextCursor *cursor = 0, bool drawSelections = FALSE,
-                        int clipx = -1, int clipy = -1, int clipw = -1, int cliph = -1 );
+            int clipx = -1, int clipy = -1, int clipw = -1, int cliph = -1 );
    virtual int topMargin() const;
    virtual int bottomMargin() const;
    virtual int leftMargin() const;
    virtual int firstLineMargin() const;
    virtual int rightMargin() const;
    virtual int lineSpacing() const;
    void registerFloatingItem( QTextCustomItem *i );
    void unregisterFloatingItem( QTextCustomItem *i );
    void setFullWidth( bool b ) { fullWidth = b; }
    bool isFullWidth() const { return fullWidth; }
    QTextTableCell *tableCell() const;
    QBrush *background() const;
    int documentWidth() const;
    int documentVisibleWidth() const;
    int documentX() const;
    int documentY() const;
    QTextFormatCollection *formatCollection() const;
    QTextFormatter *formatter() const;
@@ -1225,51 +1228,51 @@ public:
    QTextCursor *undo( QTextCursor *c = 0 );
    QTextCursor *redo( QTextCursor *c  = 0 );
    QTextCommandHistory *commands() const;
    virtual void copyParagData( QTextParagraph *parag );
    void setBreakable( bool b ) { breakable = b; }
    bool isBreakable() const { return breakable; }
    void setBackgroundColor( const QColor &c );
    QColor *backgroundColor() const { return bgcol; }
    void clearBackgroundColor();
    void setMovedDown( bool b ) { movedDown = b; }
    bool wasMovedDown() const { return movedDown; }
    void setDirection( QChar::Direction d );
    QChar::Direction direction() const;
    void readStyleInformation( QDataStream& stream );
    void writeStyleInformation( QDataStream& stream ) const;
 protected:
    virtual void drawLabel( QPainter* p, int x, int y, int w, int h, int base, const QColorGroup& cg );
    virtual void drawString( QPainter &painter, const QString &str, int start, int len, int xstart,
-                             int y, int baseLine, int w, int h, int selection,
+                 int y, int baseLine, int w, int h, int selection,
-                             QTextStringChar *formatChar, const QColorGroup& cg,
+                 QTextStringChar *formatChar, const QColorGroup& cg,
-                             bool rightToLeft );
+                 bool rightToLeft );
 private:
    QMap<int, QTextParagraphSelection> &selections() const;
    QPtrList<QTextCustomItem> &floatingItems() const;
    QBrush backgroundBrush( const QColorGroup&cg ) { if ( bgcol ) return *bgcol; return cg.brush( QColorGroup::Base ); }
    void invalidateStyleCache();
    QMap<int, QTextLineStart*> lineStarts;
    int invalid;
    QRect r;
    QTextParagraph *p, *n;
    void *docOrPseudo;
    uint changed : 1;
    uint firstFormat : 1;
    uint firstPProcess : 1;
    uint needPreProcess : 1;
    uint fullWidth : 1;
    uint lastInFrame : 1;
    uint visible : 1;
    uint breakable : 1;
    uint movedDown : 1;
    uint mightHaveCustomItems : 1;
    uint hasdoc : 1;
    uint litem : 1; // whether the paragraph is a list item
@@ -1294,52 +1297,52 @@ private:
 class Q_EXPORT QTextFormatter
 {
 public:
    QTextFormatter();
    virtual ~QTextFormatter();
    virtual int format( QTextDocument *doc, QTextParagraph *parag, int start, const QMap<int, QTextLineStart*> &oldLineStarts ) = 0;
    virtual int formatVertically( QTextDocument* doc, QTextParagraph* parag );
    bool isWrapEnabled( QTextParagraph *p ) const { if ( !wrapEnabled ) return FALSE; if ( p && !p->isBreakable() ) return FALSE; return TRUE;}
    int wrapAtColumn() const { return wrapColumn;}
    virtual void setWrapEnabled( bool b );
    virtual void setWrapAtColumn( int c );
    virtual void setAllowBreakInWords( bool b ) { biw = b; }
    bool allowBreakInWords() const { return biw; }
    int minimumWidth() const { return thisminw; }
    int widthUsed() const { return thiswused; }
    static bool isBreakable( QTextString *string, int pos );
 protected:
    virtual QTextLineStart *formatLine( QTextParagraph *parag, QTextString *string, QTextLineStart *line, QTextStringChar *start,
-                                               QTextStringChar *last, int align = Qt3::AlignAuto, int space = 0 );
+                           QTextStringChar *last, int align = Qt3::AlignAuto, int space = 0 );
 #ifndef QT_NO_COMPLEXTEXT
    virtual QTextLineStart *bidiReorderLine( QTextParagraph *parag, QTextString *string, QTextLineStart *line, QTextStringChar *start,
-                                                    QTextStringChar *last, int align, int space );
+                            QTextStringChar *last, int align, int space );
 #endif
    void insertLineStart( QTextParagraph *parag, int index, QTextLineStart *ls );
    int thisminw;
    int thiswused;
 private:
    bool wrapEnabled;
    int wrapColumn;
    bool biw;
 #ifdef HAVE_THAI_BREAKS
    static QCString *thaiCache;
    static QTextString *cachedString;
    static ThBreakIterator *thaiIt;
 #endif
 };
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 class Q_EXPORT QTextFormatterBreakInWords : public QTextFormatter
 {
 public:
    QTextFormatterBreakInWords();
@@ -1358,80 +1361,80 @@ public:
    virtual ~QTextFormatterBreakWords() {}
    int format( QTextDocument *doc, QTextParagraph *parag, int start, const QMap<int, QTextLineStart*> &oldLineStarts );
 };
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 class Q_EXPORT QTextIndent
 {
 public:
    QTextIndent();
    virtual ~QTextIndent() {}
    virtual void indent( QTextDocument *doc, QTextParagraph *parag, int *oldIndent = 0, int *newIndent = 0 ) = 0;
 };
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 class Q_EXPORT QTextPreProcessor
 {
 public:
    enum Ids {
-        Standard = 0
+    Standard = 0
    };
    QTextPreProcessor();
    virtual ~QTextPreProcessor() {}
    virtual void process( QTextDocument *doc, QTextParagraph *, int, bool = TRUE ) = 0;
    virtual QTextFormat *format( int id ) = 0;
 };
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 class Q_EXPORT QTextFormat
 {
    friend class QTextFormatCollection;
    friend class QTextDocument;
 public:
    enum Flags {
-        NoFlags,
+    NoFlags,
-        Bold = 1,
+    Bold = 1,
-        Italic = 2,
+    Italic = 2,
-        Underline = 4,
+    Underline = 4,
-        Family = 8,
+    Family = 8,
-        Size = 16,
+    Size = 16,
-        Color = 32,
+    Color = 32,
-        Misspelled = 64,
+    Misspelled = 64,
-        VAlign = 128,
+    VAlign = 128,
-        StrikeOut= 256,
+    StrikeOut= 256,
-        Font = Bold | Italic | Underline | Family | Size | StrikeOut,
+    Font = Bold | Italic | Underline | Family | Size | StrikeOut,
-        Format = Font | Color | Misspelled | VAlign
+    Format = Font | Color | Misspelled | VAlign
    };
    enum VerticalAlignment { AlignNormal, AlignSuperScript, AlignSubScript };
    QTextFormat();
    virtual ~QTextFormat();
    QTextFormat( const QStyleSheetItem *s );
    QTextFormat( const QFont &f, const QColor &c, QTextFormatCollection *parent = 0 );
    QTextFormat( const QTextFormat &fm );
    QTextFormat makeTextFormat( const QStyleSheetItem *style, const QMap<QString,QString>& attr, double scaleFontsFactor ) const;
    QTextFormat& operator=( const QTextFormat &fm );
    QColor color() const;
    QFont font() const;
    bool isMisspelled() const;
    VerticalAlignment vAlign() const;
    int minLeftBearing() const;
    int minRightBearing() const;
    int width( const QChar &c ) const;
    int width( const QString &str, int pos ) const;
    int height() const;
    int ascent() const;
    int descent() const;
    int leading() const;
@@ -1708,56 +1711,56 @@ inline void QTextDocument::setAlignment( int a )
 inline int *QTextDocument::tabArray() const
 {
    return tArray;
 }
 inline int QTextDocument::tabStopWidth() const
 {
    return tStopWidth;
 }
 inline void QTextDocument::setTabArray( int *a )
 {
    tArray = a;
 }
 inline void QTextDocument::setTabStops( int tw )
 {
    tStopWidth = tw;
 }
 inline QString QTextDocument::originalText() const
 {
    if ( oTextValid )
-        return oText;
+    return oText;
    return text();
 }
 inline void QTextDocument::setFlow( QTextFlow *f )
 {
    if ( flow_ )
-        delete flow_;
+    delete flow_;
    flow_ = f;
 }
 inline void QTextDocument::takeFlow()
 {
    flow_ = 0;
 }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 inline QColor QTextFormat::color() const
 {
    return col;
 }
 inline QFont QTextFormat::font() const
 {
    return fn;
 }
 inline bool QTextFormat::isMisspelled() const
 {
    return missp;
 }
@@ -1765,53 +1768,53 @@ inline bool QTextFormat::isMisspelled() const
 inline QTextFormat::VerticalAlignment QTextFormat::vAlign() const
 {
    return ha;
 }
 inline bool QTextFormat::operator==( const QTextFormat &f ) const
 {
    return k == f.k;
 }
 inline QTextFormatCollection *QTextFormat::parent() const
 {
    return collection;
 }
 inline void QTextFormat::addRef()
 {
    ref++;
 }
 inline void QTextFormat::removeRef()
 {
    ref--;
    if ( !collection )
-        return;
+    return;
    if ( this == collection->defFormat )
-        return;
+    return;
    if ( ref == 0 )
-        collection->remove( this );
+    collection->remove( this );
 }
 inline QString QTextFormat::key() const
 {
    return k;
 }
 inline bool QTextFormat::useLinkColor() const
 {
    return linkColor;
 }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 inline QTextStringChar &QTextString::at( int i ) const
 {
    return data[ i ];
 }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 inline QTextStringChar *QTextParagraph::at( int i ) const
 {
@@ -1822,123 +1825,123 @@ inline bool QTextParagraph::isValid() const
 {
    return invalid == -1;
 }
 inline bool QTextParagraph::hasChanged() const
 {
    return changed;
 }
 inline void QTextParagraph::setBackgroundColor( const QColor & c )
 {
    delete bgcol;
    bgcol = new QColor( c );
    setChanged( TRUE );
 }
 inline void QTextParagraph::clearBackgroundColor()
 {
    delete bgcol; bgcol = 0; setChanged( TRUE );
 }
 inline void QTextParagraph::append( const QString &s, bool reallyAtEnd )
 {
    if ( reallyAtEnd )
-        insert( str->length(), s );
+    insert( str->length(), s );
    else
-        insert( QMAX( str->length() - 1, 0 ), s );
+    insert( QMAX( str->length() - 1, 0 ), s );
 }
 inline QTextParagraph *QTextParagraph::prev() const
 {
    return p;
 }
 inline QTextParagraph *QTextParagraph::next() const
 {
    return n;
 }
 inline bool QTextParagraph::hasAnySelection() const
 {
    return mSelections ? !selections().isEmpty() : FALSE;
 }
 inline void QTextParagraph::setEndState( int s )
 {
    if ( s == state )
-        return;
+    return;
    state = s;
 }
 inline int QTextParagraph::endState() const
 {
    return state;
 }
 inline void QTextParagraph::setParagId( int i )
 {
    id = i;
 }
 inline int QTextParagraph::paragId() const
 {
    if ( id == -1 )
-        qWarning( "invalid parag id!!!!!!!! (%p)", (void*)this );
+    owarn << "invalid parag id!!!!!!!! (" << (void*)this << ")" << oendl;
    return id;
 }
 inline bool QTextParagraph::firstPreProcess() const
 {
    return firstPProcess;
 }
 inline void QTextParagraph::setFirstPreProcess( bool b )
 {
    firstPProcess = b;
 }
 inline QMap<int, QTextLineStart*> &QTextParagraph::lineStartList()
 {
    return lineStarts;
 }
 inline QTextString *QTextParagraph::string() const
 {
    return str;
 }
 inline QTextDocument *QTextParagraph::document() const
 {
    if ( hasdoc )
-        return (QTextDocument*) docOrPseudo;
+    return (QTextDocument*) docOrPseudo;
    return 0;
 }
 inline QTextParagraphPseudoDocument *QTextParagraph::pseudoDocument() const
 {
    if ( hasdoc )
-        return 0;
+    return 0;
    return (QTextParagraphPseudoDocument*) docOrPseudo;
 }
 inline QTextTableCell *QTextParagraph::tableCell() const
 {
    return hasdoc ? document()->tableCell () : 0;
 }
 inline QTextCommandHistory *QTextParagraph::commands() const
 {
    return hasdoc ? document()->commands() : pseudoDocument()->commandHistory;
 }
 inline int QTextParagraph::alignment() const
 {
    return align;
 }
 inline void QTextParagraph::registerFloatingItem( QTextCustomItem *i )
 {
    floatingItems().append( i );
 }
diff --git a/noncore/apps/tableviewer/browsekeyentry.cpp b/noncore/apps/tableviewer/browsekeyentry.cpp
index 04e7902..bab9af6 100644
--- a/noncore/apps/tableviewer/browsekeyentry.cpp
+++ b/noncore/apps/tableviewer/browsekeyentry.cpp
@@ -1,200 +1,202 @@
 /**********************************************************************
 ** 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 "browsekeyentry.h"
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #include <qtoolbutton.h>
 #include <qwidgetstack.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qpopupmenu.h>
 #include <qhbox.h>
 #include <qdatetime.h>
-//#include <iostream.h>
-#include <qheader.h>
-// For qWarning(const char *)
 /*!
    \class TVBrowseKeyEntry
    \brief a Widget used enter keys into the TVBrowseViewWidget
    The TVBrowseKeyEntry Widget provides the facility to enter
    various key types to be search on in the table.  The key can be changed
    and the entry field will update to the correct sort of widget appropriately
 */
 /*!
-    Constructs the widget 
+    Constructs the widget
 */
 TVBrowseKeyEntry::TVBrowseKeyEntry(QWidget *parent, const char *name, WFlags f)
    : QWidget(parent, name, f)
 {
    int stack_elem = 0;
    QHBoxLayout *h_layout = new QHBoxLayout(this);
    textKey = new QLineEdit(this, 0);
    dateKey = new QHBox(this, 0);
    dayKey = new QLineEdit(dateKey, 0);
    monthKey = new QLineEdit(dateKey, 0);
    yearKey = new QLineEdit(dateKey, 0);
    timeKey = new QHBox(this, 0);
    hourKey = new QLineEdit(timeKey, 0);
    minuteKey = new QLineEdit(timeKey, 0);
    secondKey = new QLineEdit(timeKey, 0);
    resetButton = new QPushButton(this, "reset");
    resetButton->setMinimumSize(QSize(50, 0));
    resetButton->setText(tr("Reset"));
    changeKeyButton = new QToolButton(this, "changekey");
    // TODO The icon stuff.
    changeKeyButton->setText(tr("key"));
    totalKeys = 0;
    ts = 0;
    keyMenu = new QPopupMenu(this, "keymenu");
    ws = new QWidgetStack(this, 0);
    ws->addWidget(textKey, stack_elem++);
    ws->addWidget(timeKey, stack_elem++);
    ws->addWidget(dateKey, stack_elem++);
    ws->raiseWidget(0);
-   
    // TODO connect slots and signals....
-    connect(changeKeyButton, SIGNAL(clicked()), 
+    connect(changeKeyButton, SIGNAL(clicked()),
            this, SLOT(changeKeyMenuSlot()));
-    connect(resetButton, SIGNAL(clicked()), 
+    connect(resetButton, SIGNAL(clicked()),
            this, SLOT(resetKeySlot()));
-    connect(textKey, SIGNAL(textChanged(const QString&)), 
+    connect(textKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(dayKey, SIGNAL(textChanged(const QString&)), 
+    connect(dayKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(monthKey, SIGNAL(textChanged(const QString&)), 
+    connect(monthKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(yearKey, SIGNAL(textChanged(const QString&)), 
+    connect(yearKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(secondKey, SIGNAL(textChanged(const QString&)), 
+    connect(secondKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(minuteKey, SIGNAL(textChanged(const QString&)), 
+    connect(minuteKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(hourKey, SIGNAL(textChanged(const QString&)), 
+    connect(hourKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
- 
    h_layout->addWidget(ws);
    h_layout->addWidget(resetButton);
    h_layout->addWidget(changeKeyButton);
 }
 /*!
-    Destructs the widget 
+    Destructs the widget
 */
 TVBrowseKeyEntry::~TVBrowseKeyEntry()
 {
 }
 /*!
    Changes which key the user intends to search on
    \param id_param the index of the key future searches should be base on
 */
 void TVBrowseKeyEntry::changeKeySlot(int id_param)
 {
    emit sortChanged(id_param);
    switch(ts->kRep->getKeyType(ts->current_column)) {
        /* work out what to raise */
        case kt_string:
        case kt_int:
            ws->raiseWidget(0);
            break;
        case kt_time:
            ws->raiseWidget(1);
            break;
        case kt_date:
            ws->raiseWidget(2);
            break;
-        default: 
+        default:
-            return; 
+            return;
    }
 }
 /*!
    Opens the change key menu
 */
 void TVBrowseKeyEntry::changeKeyMenuSlot()
 {
-    if(ts) 
+    if(ts)
        keyMenu->exec(changeKeyButton->mapToGlobal(QPoint(0,0)));
 }
 /*!
    Blanks the key entry widget
    \TODO the actual implmentation
 */
 void TVBrowseKeyEntry::resetKeySlot() {
    ;
 }
 void TVBrowseKeyEntry::setTableState(TableState *t) {
    int i;
    ts = t;
    /* clear the old */
    keyMenu->clear();
    for (i = 0; i < t->kRep->getNumFields(); i++) {
-        keyMenu->insertItem(ts->kRep->getKeyName(i), this, 
+        keyMenu->insertItem(ts->kRep->getKeyName(i), this,
                SLOT(changeKeySlot(int)), 0, i);
        keyMenu->setItemParameter(i, i);
    }
 }
 /*!
-    Searches on the current value of the key entry provided that the 
+    Searches on the current value of the key entry provided that the
-    current key is of type text WARNING, TODO fix memory leaks 
+    current key is of type text WARNING, TODO fix memory leaks
 */
 void TVBrowseKeyEntry::searchOnText()
 {
    void *sendkey;
    int tmp;
    switch(ts->kRep->getKeyType(ts->current_column)) {
        /* work out what to raise */
        case kt_string:
            sendkey = (void *)new QString(textKey->text());
            break;
        case kt_int: {
            bool ok;
            tmp = textKey->text().toInt(&ok);
            sendkey = &tmp;
            if (!ok)
                return;
            break;
        }
        case kt_time: {
            bool ok;
            int s,m,h;
            s = secondKey->text().toInt(&ok);
            if (!ok)
@@ -207,36 +209,35 @@ void TVBrowseKeyEntry::searchOnText()
                return;
            if(!QTime::isValid(h, m, s))
                return;
            sendkey = (void *) new QTime(h, m, s);
            break;
        }
        case kt_date: {
            bool ok;
            int d,m,y;
            d = dayKey->text().toInt(&ok);
            if (!ok)
                return;
            m = monthKey->text().toInt(&ok);
            if (!ok)
                return;
            y = yearKey->text().toInt(&ok);
            if (!ok)
                return;
            if(!QDate::isValid(y, m, d))
                return;
            sendkey = (void *) new QDate(y, m, d);
            break;
        }
        default:
-            qWarning("TVBrowseKeyEntry::searchOnText() "
+            owarn << "TVBrowseKeyEntry::searchOnText() cannot work out data type" << oendl;
-                     "cannot work out data type");
            return;
    }
    emit searchOnKey(ts->current_column, sendkey);
 }
 /*! \fn void TVBrowseKeyEntry::searchOnKey(int currentKeyId, void *v)
    This signal indicates that a search on key index currentKeyId should be
    done searching for the value v.
-*/ 
+*/
diff --git a/noncore/apps/tableviewer/db/common.cpp b/noncore/apps/tableviewer/db/common.cpp
index b58af85..c35dbea 100644
--- a/noncore/apps/tableviewer/db/common.cpp
+++ b/noncore/apps/tableviewer/db/common.cpp
@@ -1,44 +1,44 @@
 /**********************************************************************
 ** 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 "common.h"   
+#include "common.h"
 #include "datacache.h"
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/timestring.h>
 using namespace Opie::Core;
 /* QT */
 #include <qstring.h>
 #include <qheader.h>
 #include <qvector.h>
 #include <qdatetime.h>
 /* STD */
 #include <assert.h>
 #include <stdlib.h>
 static const int del_flag = 0x1;
 static const int new_flag = 0x2;
 /* Helper function */
 int parseNextNumber(QString *q) {
    QChar c;
@@ -67,55 +67,55 @@ int parseNextNumber(QString *q) {
 /*!
    \class QStringVector
    \brief A Vector of QStrings that can be sorted and searched
    Implmented in order to allow reverse lookup on the string name
 */
 /*!
    This function implements the compare function in order to allow the
    searching and sorting of the QStringVector to occur
    \returns an int which is either
    <UL>
    <LI> < 0 if the first string is smaller than the second,</LI>
    <LI> > 0 if the first string is bigger then the second,</LI>
    <LI> == 0 if the first string is equal to the second.</LI>
    </UL>
 */
 int QStringVector::compareItems(Item a, Item b)
 {
    QString *qa = (QString *)a;
    QString *qb = (QString *)b;
-         
    return QString::compare(*qa, *qb);
 }
 /*!
    \class TVVariant
-    A way of abstracting void * and keeping information on 
+    A way of abstracting void * and keeping information on
    the keytypes and behaviours in one place
 */
 TVVariantPrivate::TVVariantPrivate()
 {
    typ = TVVariant::Invalid;
 }
 TVVariantPrivate::TVVariantPrivate( TVVariantPrivate *d)
 {
    switch(d->typ)
    {
        case TVVariant::Invalid:
            break;
        case TVVariant::String:
            value.ptr = new QString(*((QString *)d->value.ptr));
            break;
        case TVVariant::Date:
            value.ptr = new QDate(*((QDate *)d->value.ptr));
            break;
        case TVVariant::Time:
            value.ptr = new QTime(*((QTime *)d->value.ptr));
            break;
        case TVVariant::Int:
@@ -299,49 +299,49 @@ void TVVariant::load(QDataStream &s )
            }
            break;
        case Time:
            {
                QTime *x = new QTime;
                s >> *x;
                d->value.ptr = x;
            }
            break;
        case Date:
            {
                QDate *x = new QDate;
                s >> *x;
                d->value.ptr = x;
            }
            break;
        case Int:
            {
                int x;
                s >> x;
                d->value.i = x;
            }
      break;
        default:
-      ofatal << "Unrecognized data type" << oendl; 
+      ofatal << "Unrecognized data type" << oendl;
    }
 }
 void TVVariant::save( QDataStream &s ) const
 {
    s << type();
    switch( d->typ ) {
        case String:
            s << *((QString *)d->value.ptr);
            break;
        case Date:
            s << *((QDate *)d->value.ptr);
            break;
        case Time:
            s << *((QTime *)d->value.ptr);
            break;
        case Int:
            s << d->value.i;
            break;
        case Invalid:
            break;
    }
 }
@@ -361,121 +361,121 @@ QDataStream& operator<<(QDataStream &s, const TVVariant& p)
 QDataStream& operator>> (QDataStream &s, TVVariant::KeyType& p)
 {
    Q_UINT8 u = 0;
    s >> u;
    p = (TVVariant::KeyType) u;
    return s;
 }
 QDataStream& operator<< (QDataStream& s, const TVVariant::KeyType& p)
 {
    s << (Q_UINT8)p;
    return s;
 }
 const QString TVVariant::toString() const
 {
    switch(d->typ) {
        case String:
            return *((QString*)d->value.ptr);
        case Date:
            return ((QDate*)d->value.ptr)->toString();
        case Time:
            return ((QTime*)d->value.ptr)->toString();
-        case Int: 
+        case Int:
                return QString::number(d->value.i);
        case Invalid:
        default:
            return QString::null;
    }
    return QString::null;
 }
 // TODO DO, this properly, */
 int TVVariant::toInt() const
 {
    if(d->typ == Int)
        return d->value.i;
    if(d->typ == String) {
      QString tmpq(*(QString *)d->value.ptr);
        return parseNextNumber(&tmpq);
    }
    return 0;
 }
 const QDate TVVariant::toDate() const
 {
    if(d->typ == Date)
        return *((QDate *)d->value.ptr);
    if(d->typ == String) {
        QString q = toString();
        /* date format is day mon d yyyy */
        /* ignore the first three letters, read the next
           three for month.. etc */
        int day = parseNextNumber(&q);
        int month = parseNextNumber(&q);
        int year = parseNextNumber(&q);
        if (!QDate::isValid(year, month, day))
            return QDate();
        return QDate(year, month, day);
    }
-        
    return QDate();
 }
 const QTime TVVariant::toTime() const
 {
    if(d->typ == Time)
        return *((QTime *)d->value.ptr);
-    
    if(d->typ == String) {
        QString q = toString();
        int hour = parseNextNumber(&q);
        int minute = parseNextNumber(&q);
        int second = parseNextNumber(&q);
        int msecond = parseNextNumber(&q);
        if (!QTime::isValid(hour, minute, second, msecond))
            return QTime();
        return QTime(hour, minute, second, msecond);
    }
    return QTime();
 }
 #define TV_VARIANT_AS( f ) Q##f& TVVariant::as##f() { \
    if ( d->typ != f ) \
        *this = TVVariant( to##f() ); \
    else \
        detach(); \
    return *((Q##f*)d->value.ptr); }
- 
 TV_VARIANT_AS(String)
 TV_VARIANT_AS(Date)
 TV_VARIANT_AS(Time)
 #undef TV_VARIANT_AS
 int& TVVariant::asInt()
 {
    detach();
    if (d->typ != Int) {
        d->value.i = toInt();
        d->typ = Int;
    }
    return d->value.i;
 }
 /*!
    valid cast is
    anything to String
    same to same
 */
 bool TVVariant::canCast(KeyType t) const
 {
    if(d->typ == t)
@@ -539,186 +539,186 @@ bool TVVariant::operator<( const TVVariant &v ) const
 bool TVVariant::operator>( const TVVariant &v ) const
 {
    switch(d->typ) {
        case String:
            return toString().lower() > v.toString().lower();
        case Date:
            return toDate() > v.toDate();
        case Time:
            return toTime() > v.toTime();
        case Int:
            return toInt() > v.toInt();
        case Invalid:
        default:
            break;
    }
    return FALSE;
 }
 /*! True if n is closer to this than o */
 bool TVVariant::closer(TVVariant n, TVVariant o)
 {
    /* Nothing is close to an invalid, so nothing can be closer */
    if(d->typ == Invalid)
-        return FALSE; 
+        return FALSE;
    /* can't be closer if of different type */
    if(n.type() != type())
        return FALSE;
    /* if new shares type, and old doesn't, then new is closer */
    if(o.type() != type())
        return TRUE;
    switch(type()){
        case String: {
-            /* case for strings is close is a substring.. closer is 
+            /* case for strings is close is a substring.. closer is
             * earlier alphabetically */
            QString qs1 = n.toString().lower();
            QString qs2 = o.toString().lower();
            QString qsv = toString().lower();
            if (!qs1.startsWith(qsv))
                return FALSE;
            /* contains sub-str, if later than is not closer */
-            if(QString::compare(qs1, qs2) > 0) 
+            if(QString::compare(qs1, qs2) > 0)
                return FALSE;
            return TRUE;
        }
        case Int: {
            /* case for int is smallest absolute difference */
            int i1 = n.toInt();
            int i2 = o.toInt();
            int iv = toInt();
            int diff1 = (i1 - iv);
-            if (diff1 < 0) 
+            if (diff1 < 0)
                diff1 = -diff1;
            int diff2 = (i2 - iv);
-            if (diff2 < 0) 
+            if (diff2 < 0)
                diff2 = -diff2;
-            if (diff1 < diff2) 
+            if (diff1 < diff2)
                return TRUE;
            return FALSE;
        }
        case Date: {
            QDate i1 = n.toDate();
            QDate i2 = o.toDate();
            QDate iv = toDate();
            /* definition of closer is the least difference in days */
            int diff1 = i1.daysTo(iv);
-            if (diff1 < 0) 
+            if (diff1 < 0)
                diff1 = -diff1;
            int diff2 = i2.daysTo(iv);
-            if (diff2 < 0) 
+            if (diff2 < 0)
                diff2 = -diff2;
            if (diff1 < diff2)
                return TRUE;
            return FALSE;
        }
        case Time: {
            QTime i1 = n.toTime();
            QTime i2 = o.toTime();
            QTime iv = toTime();
            /* definition of closer is the least difference in days */
            int diff1 = i1.msecsTo(iv);
-            if (diff1 < 0) 
+            if (diff1 < 0)
                diff1 = -diff1;
            int diff2 = i2.msecsTo(iv);
-            if (diff2 < 0) 
+            if (diff2 < 0)
                diff2 = -diff2;
            if (diff1 < diff2)
                return TRUE;
            return FALSE;
        }
        default:
            /* don't know how to do 'closer' on this type, hence never closer
             * or even close */
            break;
    }
    return FALSE;
 }
 /*! True if n is close to this */
 bool TVVariant::close(TVVariant n)
 {
    /* Nothing is close to an invalid, so nothing can be closer */
    if(type() == Invalid)
-        return FALSE; 
+        return FALSE;
    /* can't be close if of different type */
    if(n.type() != type())
        return FALSE;
    switch(type()){
        case String: {
-            /* case for strings is close is a substring.. closer is 
+            /* case for strings is close is a substring.. closer is
             * earlier alphabetically */
            QString qs1 = n.toString().lower();
            QString qsv = toString().lower();
            if (!qs1.startsWith(qsv))
                return FALSE;
            return TRUE;
        }
-        case Int: 
+        case Int:
        case Date:
        case Time:
            return TRUE;
        default:
            /* don't know how to do 'closer' on this type, hence never closer
             * or even close */
            break;
    }
    return FALSE;
 }
 /*!
    \class Key
    \brief document me!
-    
    document me!
 */
 Key::Key() : kname(), kexample(), kflags(0) { }
 Key::Key(QString name, TVVariant example, int flags) :
-    kname(name), kexample(example), kflags(flags) { } 
+    kname(name), kexample(example), kflags(flags) { }
 Key::Key(const Key &other)
 {
  kname = other.kname;
  kexample = other.kexample;
  kflags = other.kflags;
 }
-Key& Key::operator=(const Key& key) 
+Key& Key::operator=(const Key& key)
 {
    kname = key.kname;
    kexample = key.kexample;
    kflags = key.kflags;
    return *this;
 }
 QString Key::name() const
 {
    return QString(kname);
 }
 TVVariant Key::example() const
 {
    return TVVariant(kexample);
 }
 TVVariant::KeyType Key::type() const
 {
    return kexample.type();
 }
 void Key::setName(const QString &name)
 {
@@ -756,206 +756,205 @@ bool Key::newFlag() const
 void Key::setDelFlag(bool v)
 {
    if(delFlag() != v)
        kflags = kflags ^ del_flag;
 }
 void Key::setNewFlag(bool v)
 {
    if(newFlag() != v)
        kflags = kflags ^ new_flag;
 }
 /*!
    \class KeyList
    \brief A represntation of keys used for a table.
    The KeyList class is used to store the representation of keys used in table
    headings by DBStore.  It stores the names and types of the keys
 */
 /*!
    Constructs a KeyList
 */
-KeyList::KeyList() : QIntDict<Key>(20) 
+KeyList::KeyList() : QIntDict<Key>(20)
 {
    setAutoDelete(TRUE);
 }
 /* Should be deep copy, but isn't */
-KeyList::KeyList(const KeyList &k) : QIntDict<Key>(k) 
+KeyList::KeyList(const KeyList &k) : QIntDict<Key>(k)
 {
    KeyListIterator it(k);
  while(it.current()) {
    replace(it.currentKey(), new Key(*it.current()));
    ++it;
  }
    setAutoDelete(TRUE);
 }
 /*!
    Destroys a KeyList
 */
 KeyList::~KeyList() {
 }
 /* Do a comparision base on Keys */
 bool KeyList::operator!=(const KeyList &other)
 {
    KeyListIterator it(*this);
    if (other.getNumFields() != getNumFields())
  return TRUE;
    while(it.current()) {
  //it.currentKey(), it.current();
  if (other.getKeyName(it.currentKey()) != getKeyName(it.currentKey()))
      return TRUE;
  if (other.getKeyType(it.currentKey()) != getKeyType(it.currentKey()))
      return TRUE;
  ++it;
    }
    return FALSE;
 }
 /*!
    Returns the number of keys stored in the KeyList
 */
-int KeyList::getNumFields() const 
+int KeyList::getNumFields() const
 {
    return count();
 }
 /*!
    Adds a new key to the KeyList
    \param name the name of the new key
    \param type the type of the new key
 */
 int KeyList::addKey(QString name, TVVariant example)
 {
    int i = count();
    while(find(i) && (i > -1))
        i--;
    replace(i, new Key(name, example, 0));
    return i;
 }
 int KeyList::addKey(QString name, TVVariant::KeyType type)
 {
    /* generate a valid type for the example? */
    TVVariant e = TVVariant("0");
    switch(type) {
-        case TVVariant::String: 
+        case TVVariant::String:
            return addKey(name, TVVariant("<undefined>").asString());
            break;
-        case TVVariant::Date: 
+        case TVVariant::Date:
            return addKey(name, TVVariant(QDate::currentDate()).asDate());
            break;
-        case TVVariant::Time: 
+        case TVVariant::Time:
            return addKey(name, TVVariant(QTime(0,0,0)).toTime());
            break;
-        case TVVariant::Int: 
+        case TVVariant::Int:
            return addKey(name, TVVariant(0).toInt());
            break;
        default:
-            qWarning(QObject::tr("KeyList::addKey() Cannot make default "
+            owarn << "KeyList::addKey() Cannot make default value for type " << type << ", Key not added." << oendl;
-                        "value for type %1, Key not added.").arg(type));
            break;
    }
    return -1;
 }
-void KeyList::setKeyFlags(int i, int flag) 
+void KeyList::setKeyFlags(int i, int flag)
 {
    if(find(i))
        find(i)->setFlags(flag);
 }
 int KeyList::getKeyFlags(int i) const
 {
    if(find(i))
        return find(i)->flags();
    return 0;
 }
-bool KeyList::checkNewFlag(int i) const 
+bool KeyList::checkNewFlag(int i) const
 {
    if (find(i))
        return find(i)->newFlag();
    return false;
 }
-void KeyList::setNewFlag(int i, bool f) 
+void KeyList::setNewFlag(int i, bool f)
 {
    if(!find(i))
        return;
    find(i)->setNewFlag(f);
 }
-bool KeyList::checkDeleteFlag(int i) const 
+bool KeyList::checkDeleteFlag(int i) const
 {
    if (find(i))
        return find(i)->delFlag();
    return false;
 }
-void KeyList::setDeleteFlag(int i, bool f) 
+void KeyList::setDeleteFlag(int i, bool f)
 {
    if(!find(i))
        return;
    find(i)->setDelFlag(f);
 }
 /*!
    Returns the name of the key at index i
 */
 QString KeyList::getKeyName(int i) const
 {
    if (find (i))
        return find(i)->name();
    return QString();
 }
-void KeyList::setKeyName(int i, const QString &n) 
+void KeyList::setKeyName(int i, const QString &n)
 {
    if(find(i))
        find(i)->setName(n);
 }
 /*!
    Returns the type of the key at index i
 */
 TVVariant::KeyType KeyList::getKeyType(int i) const
 {
    if(find(i))
        return find(i)->type();
    return TVVariant::Invalid;
 }
-void KeyList::setKeyType(int i, TVVariant::KeyType t) 
+void KeyList::setKeyType(int i, TVVariant::KeyType t)
 {
    if(!find(i))
        return;
    switch(t) {
        case TVVariant::String:
            find(i)->setExample(TVVariant(QString("default")));
            return;
        case TVVariant::Int:
            find(i)->setExample(TVVariant(int(0)));
            return;
        case TVVariant::Date:
            find(i)->setExample(TVVariant(QDate::currentDate()));
            return;
        case TVVariant::Time:
            find(i)->setExample(TVVariant(QTime(0,0,0,0)));
            return;
        default:
            break;
    }
    return;
 }
 TVVariant KeyList::getKeyExample(int i) const
 {
@@ -1019,328 +1018,326 @@ QDataStream &operator>>( QDataStream &s, KeyList &k)
    TVVariant type = TVVariant();
    QString name;
    s >> size;
    for (i=0; i < size; i++) {
        s >> (Q_UINT16 &)index;
        s >> name;
        s >> type;
        s >> (Q_UINT16 &)flags;
        k.replace(index, new Key(name, type, flags));
    }
    return s;
 }
 /*!
    \class DataElem
    \brief A class representing a single row or element of a table in a DBStore
    This class holds the data of a row in a table.
 */
 /*!
-    Constructs a DataElem.  This function needs a container because the 
+    Constructs a DataElem.  This function needs a container because the
-    size, types of keys and primary key are all defined by the containing 
+    size, types of keys and primary key are all defined by the containing
-    database 
+    database
 */
 DataElem::DataElem(DBStore *c) : values(20)
 {
    int size;
    contained = c;
    size = c->getNumFields();
    values.setAutoDelete(TRUE);
 }
 /*!
    Destroys a DataElem and frees memory used by the DataElem
 */
 DataElem::~DataElem() {
 }
 QDataStream &operator<<( QDataStream &s, const DataElem &d)
 {
    int size = d.getNumFields();
    s << size; /* redundent data but makes streaming easier */
    KeyList k = d.getKeys();
    KeyListIterator it(k);
    while(it.current()) {
        s << (Q_UINT16)it.currentKey();
        s << d.getField(it.currentKey());
        ++it;
    }
    return s;
 }
 QDataStream &operator>>( QDataStream &s, DataElem &d)
 {
    int i;
    int size;
    TVVariant t;
    Q_UINT16 index = 0;
    s >> size; /* redundent data but makes streaming easier */
    if (size != d.getNumFields()) {
-        owarn << "DataSize mis-match" << oendl; 
+        owarn << "DataSize mis-match" << oendl;
        return s; /* sanity check failed.. don't load */
    }
    for(i = 0; i < size; i++) {
        s >> index;
        s >> t;
        d.setField(index, t);
    }
    return s;
 }
 /*! Returns the number of possible (not valid) fields in the data element */
 int DataElem::getNumFields() const
 {
    return contained->getNumFields();
 }
 KeyList DataElem::getKeys() const
 {
    return *(contained->getKeys());
 }
-/*! 
+/*!
    This function determines whether field index i of the element has been
    set yet.
-    \return A boolean value that is TRUE if the specfied field of this 
+    \return A boolean value that is TRUE if the specfied field of this
-    element has been set and FALSE if the field has not yet been set 
+    element has been set and FALSE if the field has not yet been set
 */
 bool DataElem::hasValidValue(int i) const
 {
    if(!values.find(i))
        return FALSE;
-    if(!contained->getKeys()->validIndex(i)) 
+    if(!contained->getKeys()->validIndex(i))
        return FALSE;
    return values.find(i)->isValid();
 }
-/*! 
+/*!
    This function determines whether field name qs of the element has been
    set yet.
-    \return A boolean value that is TRUE if the specfied field of this 
+    \return A boolean value that is TRUE if the specfied field of this
-    element has been set and FALSE if the field has not yet been set 
+    element has been set and FALSE if the field has not yet been set
 */
-bool DataElem::hasValidValue(QString qs) const 
+bool DataElem::hasValidValue(QString qs) const
 {
    int i = contained->getKeyIndex(qs);
    return hasValidValue(i);
 }
 /*!  returns the type of the field specified by index i */
-TVVariant::KeyType DataElem::getFieldType(int i) const 
+TVVariant::KeyType DataElem::getFieldType(int i) const
 {
    return contained->getKeyType(i);
 }
 /*!  returns the type of the field specified by name qs */
 TVVariant::KeyType DataElem::getFieldType(QString qs) const
 {
    int i = contained->getKeyIndex(qs);
    return contained->getKeyType(i);
 }
-/*!  
+/*!
-    returns a pointer to the data stored in field index i for this 
+    returns a pointer to the data stored in field index i for this
-    data element, (value may not be valid) 
+    data element, (value may not be valid)
 */
 TVVariant DataElem::getField(int i) const
 {
    if(hasValidValue(i))
        return TVVariant(*values.find(i));
    return TVVariant();
 }
-/*!  
+/*!
-    returns a pointer to the data stored in field name qs for this 
+    returns a pointer to the data stored in field name qs for this
-    data element, (value may not be valid) 
+    data element, (value may not be valid)
 */
 TVVariant DataElem::getField(QString qs) const
 {
    int i = contained->getKeyIndex(qs);
    return getField(i);
 }
 /*!
    Sets the value of the elements field index i to the value represented in
    the QString q.
    \param i index of the field to set
    \param q a string that can be parsed to get the value to be set
 */
-void DataElem::setField(int i, QString q) 
+void DataElem::setField(int i, QString q)
 {
    /* from the type of the field, parse q and store */
    TVVariant::KeyType kt = contained->getKeyType(i);
    TVVariant t = TVVariant(q);
    switch(kt) {
        case TVVariant::Int: {
            t.asInt();
            setField(i, t);
      return;
        }
        case TVVariant::String: {
            t.asString();
            setField(i, t);
            return;
        }
        case TVVariant::Date: {
            t.asDate();
            setField(i, t);
            return;
        }
        case TVVariant::Time: {
            t.asTime();
            setField(i, t);
            return;
        }
        default:
-            qWarning(
+            owarn << "DataElem::setField(" << i << ", " << q << ") No valid type found" << oendl;
-                QObject::tr("DataElem::setField(%1, %2) No valid type found").arg(i).arg(q)
-                );
    }
 }
 /*!
    Sets the value of the elements field index i to the value at the pointer
    value.
    \param i index of the field to set
-    \param value a pointer to the (already allocated) value to set 
+    \param value a pointer to the (already allocated) value to set
 */
-void DataElem::setField(int i, TVVariant value) 
+void DataElem::setField(int i, TVVariant value)
 {
    if (value.isValid()) {
        values.remove(i);
        values.replace(i, new TVVariant(value));
    }
 }
 /*!
    Sets the value of the elements field name qs to the value represented in
    the QString q.
    \param qs name of the field to set
    \param q a string that can be parsed to get the value to be set
 */
-void DataElem::setField(QString qs, QString q) 
+void DataElem::setField(QString qs, QString q)
 {
    /* from the type of the field, parse q and store */
    int i = contained->getKeyIndex(qs);
    setField(i, qs);
 }
 /*!
    Sets the value of the elements field name qs to the value at the pointer
    value.
    \param qs name of the field to set
-    \param value a pointer to the (already allocated) value to set 
+    \param value a pointer to the (already allocated) value to set
 */
 void DataElem::setField(QString qs, TVVariant value)
 {
    int i = contained->getKeyIndex(qs);
    setField(i, value);
 }
 void DataElem::unsetField(int i) {
    values.remove(i);
 }
 void DataElem::unsetField(QString qs)
 {
    int i = contained->getKeyIndex(qs);
    unsetField(i);
 }
 /*!
-    Converts the data element to a Rich Text QString 
+    Converts the data element to a Rich Text QString
 */
 QString DataElem::toQString() const
 {
    /* lets make an attempt at this function */
    int i;
    QString scratch = "";
    QIntDictIterator<TVVariant> it(values);
    while (it.current()) {
      i = it.currentKey();
        if(hasValidValue(i)) {
            scratch += "<B>" + contained->getKeyName(i) + ":</B> ";
            scratch += getField(i).toString();
            scratch += "<br>";
        }
        ++it;
    }
    return scratch;
 }
 /*! formats individual fields to strings so can be displayed */
-QString DataElem::toQString(int i) const 
+QString DataElem::toQString(int i) const
 {
    if(hasValidValue(i)) {
        return getField(i).toString();
    }
    return "";
 }
 /*! formats individual fields to strings so can be sorted by QListView */
-QString DataElem::toSortableQString(int i) const 
+QString DataElem::toSortableQString(int i) const
 {
    QString scratch = "";
    if(hasValidValue(i)) {
        switch (contained->getKeyType(i)) {
            case TVVariant::String: {
                scratch += getField(i).toString();
                break;
            }
            case TVVariant::Int: {
                scratch.sprintf("%08d", getField(i).toInt());
                break;
            }
            case TVVariant::Date: {
                static QDate epochD(1800, 1, 1);
-                scratch.sprintf("%08d", 
+                scratch.sprintf("%08d",
                                epochD.daysTo(getField(i).toDate()));
                break;
            }
            case TVVariant::Time: {
                static QTime epochT(0, 0, 0);
-                scratch.sprintf("%08d", 
+                scratch.sprintf("%08d",
                                epochT.msecsTo(getField(i).toTime()));
                break;
            }
            default:
                scratch += "Unknown type";
                break;
        }
    }
    return scratch;
 }
 /* compare functions */
 bool DataElem::lessThan(int i, TVVariant v) const
 {
    if (!hasValidValue(i)) return FALSE;
    if (getField(i).type() != v.type())
        return FALSE;
    return (getField(i) < v);
 }
 bool DataElem::moreThan(int i, TVVariant v) const
@@ -1359,120 +1356,120 @@ bool DataElem::equalTo(int i, TVVariant v) const
    if (getField(i).type() != v.type())
        return FALSE;
    return (getField(i) == v);
 }
 bool DataElem::contains(int i, TVVariant v) const
 {
    if (!hasValidValue(i)) return FALSE;
    if (getField(i).type() != v.type())
        return FALSE;
    switch(getField(i).type()) {
        case TVVariant::String: {
            QString qs1 = getField(i).toString().lower();
            QString qs2 = v.toString().lower();
            if (qs1.contains(qs2) > 0) return TRUE;
            break;
        }
            /* meaningless for ints */
            /* meaningless for time */
            /* meaningless for dates */
-        case TVVariant::Int: 
+        case TVVariant::Int:
        case TVVariant::Time:
        case TVVariant::Date:
            break;
        default:
-            owarn << "Tried to compare unknown data type" << oendl; 
+            owarn << "Tried to compare unknown data type" << oendl;
    }
    return FALSE;
 }
 bool DataElem::startsWith(int i, TVVariant v) const
 {
    if (!hasValidValue(i)) return FALSE;
    if (getField(i).type() != v.type())
        return FALSE;
    switch(getField(i).type()) {
        case TVVariant::String: {
            QString qs1 = getField(i).toString().lower();
            QString qs2 = v.toString().lower();
            return qs1.startsWith(qs2);
        }
            /* meaningless for ints */
            /* meaningless for time */
            /* meaningless for dates */
-        case TVVariant::Int: 
+        case TVVariant::Int:
        case TVVariant::Time:
        case TVVariant::Date:
            return FALSE;
        default:
-            owarn << "Tried to compare unknown data type" << oendl; 
+            owarn << "Tried to compare unknown data type" << oendl;
    }
    return FALSE;
 }
 bool DataElem::endsWith(int i, TVVariant v) const
 {
    if (!hasValidValue(i)) return FALSE;
    if (getField(i).type() != v.type())
        return FALSE;
    switch(getField(i).type()) {
        case TVVariant::String: {
            QString qs1 = getField(i).toString().lower();
            QString qs2 = v.toString().lower();
            return qs1.startsWith(qs2);
        }
            /* meaningless for ints */
            /* meaningless for time */
            /* meaningless for dates */
-        case TVVariant::Int: 
+        case TVVariant::Int:
        case TVVariant::Time:
        case TVVariant::Date:
            return FALSE;
        default:
-            owarn << "Tried to compare unknown data type" << oendl; 
+            owarn << "Tried to compare unknown data type" << oendl;
    }
    return FALSE;
 }
 /*!
    Determins which of the first to parameters are closer to the third, target
    parameter.
-    \return 
+    \return
    <UL>
-    <LI>TRUE if the first element is a closer match to the target than the 
+    <LI>TRUE if the first element is a closer match to the target than the
    second element</LI>
    <LI>FALSE if the first element is not a closer match to the target than
    the second element</LI>
    </UL>
 */
 bool DataElem::closer(DataElem*d1, DataElem *d2, TVVariant target, int column)
 {
-    int type; 
+    int type;
    if(!d1) return FALSE;
    if (!d1->hasValidValue(column)) return FALSE;
    if(!target.isValid()) return FALSE;
    type = d1->getField(column).type();
    if(d2) {
        if (type != d2->getField(column).type()) {
                /* can't do compare */
-                owarn << "Tried to compare two incompatable types" << oendl; 
+                owarn << "Tried to compare two incompatable types" << oendl;
                return FALSE;
        }
        return target.closer(d1->getField(column), d2->getField(column));
-    } 
+    }
    return target.close(d1->getField(column));
 }
diff --git a/noncore/apps/tableviewer/db/datacache.cpp b/noncore/apps/tableviewer/db/datacache.cpp
index 6380e1b..de57961 100644
--- a/noncore/apps/tableviewer/db/datacache.cpp
+++ b/noncore/apps/tableviewer/db/datacache.cpp
@@ -1,301 +1,301 @@
 /**********************************************************************
 ** 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.
 **
-**********************************************************************/ 
+**********************************************************************/
 /*
 * This file is used to load the xml files that represent the database.
 * The main requirment for said file is each data entry must contain a key,
 * otherwise any other data headings are allowed.
 */
 #include "datacache.h"
 #include "xmlsource.h"
 #include "csvsource.h"
 /* OPIE */
 #include <opie2/odebug.h>
 using namespace Opie::Core;
 /* QT */
 #include <qheader.h>
 /* STD */
 #include <stdlib.h>
 #define INIT_TABLE_SIZE 128
 /*!
    \class DBStore datastore.h
    \brief The DBStore class is the class responsible for storing, sorting and
    searching the data loaded by the application
 */
 /*!
    Constructs a DBStore item
 */
 DBStore::DBStore()
 {
    name = "";
    number_elems = 0;
    full = false;
    kRep = new KeyList();
    master_table.resize(INIT_TABLE_SIZE);
    table_size = INIT_TABLE_SIZE;
    current_elem = 0;
    archive = 0;
 }
-//TODO 
+//TODO
 /*!
-    Reinitializes the table to empty (include a resize of the master table, 
+    Reinitializes the table to empty (include a resize of the master table,
-    which should free some memory) 
+    which should free some memory)
 */
 void DBStore::freeTable()
 {
    name = "";
    if(archive) {
        delete archive;
        archive = 0;
    }
    kRep->clear(); /* clear the current key list */
    number_elems = 0;
    table_size = INIT_TABLE_SIZE;
    master_table.resize(table_size);
    full = false;
    current_elem = 0;
 }
 /*!
    Removes all items from the DBStore and destroys the DBStore
 */
 DBStore::~DBStore()
 {
    freeTable();
 }
 /*!
-    This function opens the given xml file, loads it and sets up the 
+    This function opens the given xml file, loads it and sets up the
    appropriate data structures.
    \param file_name A string representing the name of the file to be opened
    \return true if successful, false otherwise.
 */
 bool DBStore::openSource(QIODevice *inDev, const QString &source) {
-        /* first check if db is already open, if contains data.. then clear */
+    /* first check if db is already open, if contains data.. then clear */
    if(number_elems > 0) {
        freeTable();
    }
    if (source == "text/x-xml-tableviewer") {
        archive = new DBXml(this);
    } else if (source == "text/csv") {
-        archive = new DBCsv(this);
+    archive = new DBCsv(this);
    } else
-            return false;
+        return false;
    return (archive->openSource(inDev));
 }
-bool DBStore::saveSource(QIODevice *outDev, const QString &source) 
+bool DBStore::saveSource(QIODevice *outDev, const QString &source)
 {
    /* saving a new file */
    if(!archive) {
        if (source == "text/x-xml-tableviewer") {
            archive = new DBXml(this);
-        } else if (source == "text/x-xml-tableviewer") {
+    } else if (source == "text/x-xml-tableviewer") {
            archive = new DBCsv(this);
        } else
-            return false;
+        return false;
    }
    /* changing file type */
    if(archive->type() != source) {
        delete archive;
        if (source == "text/x-xml-tableviewer") {
            archive = new DBXml(this);
-        } else if (source == "text/x-xml-tableviewer") {
+    } else if (source == "text/x-xml-tableviewer") {
            archive = new DBCsv(this);
-        } else 
+        } else
-            return false;
+        return false;
    }
    return (archive->saveSource(outDev));
 }
-/*! 
+/*!
    This function is used to add new elements to the database.  If the database
    has already reached the maximum allowable size this function does not alter
    the database.
    \param delm An already allocated and initialized data element to be added
 */
 void DBStore::addItem(DataElem *delem)
 {
    addItemInternal(delem);
 }
 void DBStore::addItemInternal(DataElem *delem)
 {
-    /* if already full, don't over fill, do a qWarning though */
+    /* if already full, don't over fill, do a owarn though */
    if (full) {
-        owarn << "Attempted to add items to already full table" << oendl; 
+        owarn << "Attempted to add items to already full table" << oendl;
        return;
    }
    master_table.insert(number_elems, delem);
    current_elem = number_elems;
    number_elems++;
    if(number_elems >= table_size) {
        /* filled current table, double if we can */
        table_size = table_size << 1;
        /* check that the new table size is still valid, i.e. that we didn't
           just shift the 1 bit of the end of the int. */
        if (!table_size) {
            full = true;
            /* no point in doing antying else. */
            return;
        }
        master_table.resize(table_size);
    }
 }
 void DBStore::removeItem(DataElem *r)
 {
    int position = master_table.findRef(r);
-        if(position != -1) {
+    if(position != -1) {
-                /* there is at least one item, this is it */
+        /* there is at least one item, this is it */
-                /* replace this with the last element, decrease the element count */
+        /* replace this with the last element, decrease the element count */
-                master_table.insert(position, master_table.at(--number_elems));
+        master_table.insert(position, master_table.at(--number_elems));
-                master_table.remove(number_elems);
+        master_table.remove(number_elems);
-                delete r;
+        delete r;
-        }
+    }
 }
 /*!
    Sets the name of the database
    \param n A string representing the new name of the database.
 */
 void DBStore::setName(const QString &n)
 {
-        name = n;
+    name = n;
 }
 /*!
    Gets the name of the database
    \return A string representing the name of the database.
 */
 QString DBStore::getName()
 {
-        return name;
+    return name;
 }
 /*!
-    Retrieves a pointer to the key representation of the database for 
+    Retrieves a pointer to the key representation of the database for
    other classes to use as reference.
    \return a pointer to the databases key representaion
 */
 KeyList *DBStore::getKeys()
 {
    return kRep;
 }
 /*!
    sets the database's key representation the passed pointer
    \param a pointer to a key representaton
 */
 void DBStore::setKeys(KeyList *k)
 {
    kRep = k;
 }
 /*!
-    Sets the current element to the first element of the database 
+    Sets the current element to the first element of the database
 */
 void DBStore::first()
 {
    current_elem = 0;
 }
 /*!
-    Sets the current element to the last element of the database 
+    Sets the current element to the last element of the database
 */
 void DBStore::last()
 {
    current_elem = number_elems - 1;
 }
 /*!
    Sets the current element to the next element of the database if
    there exists an element after the current one.
 */
 bool DBStore::next()
 {
    unsigned int new_current_elem = current_elem + 1;
-    if (current_elem < number_elems) 
+    if (current_elem < number_elems)
        /* was valid before inc (it is possible but unlikely that inc current
           elem will change it from invalid to valid) */
        if (new_current_elem < number_elems) {
            /* is valid after inc */
            current_elem = new_current_elem;
            return true;
        }
    return false;
 }
 /*!
    Sets the current element to the previous element of the database if
    there exists an element before the current one.
 */
 bool DBStore::previous()
 {
    unsigned int new_current_elem = current_elem -1;
    if (current_elem < number_elems)
        /* was valid */
        if (new_current_elem < number_elems) {
-            /* still is (if was 0, then now -1, but as is unsigned will wrap 
+            /* still is (if was 0, then now -1, but as is unsigned will wrap
               and hence be invalid */
            current_elem = new_current_elem;
            return true;
        }
    return false;
 }
 /*!
    Returns the current data element in the database.  Which element is current
-    is affected by newly added items, findItem, next, previous, first and 
+    is affected by newly added items, findItem, next, previous, first and
    last functions
    \return a pointer to the current data element
 */
-DataElem *DBStore::getCurrentData() 
+DataElem *DBStore::getCurrentData()
 {
-    if (current_elem >= number_elems) 
+    if (current_elem >= number_elems)
        return NULL;
    return master_table[current_elem];
 }
diff --git a/noncore/apps/tableviewer/db/datacache.h b/noncore/apps/tableviewer/db/datacache.h
index c5dc637..e38050c 100644
--- a/noncore/apps/tableviewer/db/datacache.h
+++ b/noncore/apps/tableviewer/db/datacache.h
@@ -6,125 +6,131 @@
 ** 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.
 **
 **********************************************************************/
 /*
 * This file is used to load the xml files that represent the database.
 * The main requirment for said file is each data entry must contain a key,
 * otherwise any other data headings are allowed.
 */
 #ifndef __DATACACHE_H__
 #define __DATACACHE_H__
+#include "common.h"
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #include <qstring.h>
 #include <qvector.h>
-#include "common.h"
 class DBStore;
 /*! Abstract class that defines how database stuff can be accessed */
 class DBAccess {
 public:
 //    DBAccess(DBStore *d) { dstore = d; }
    virtual ~DBAccess() {}
    virtual QString type() {
        return QString();
    }
    virtual bool openSource(QIODevice *) {
-        qWarning("DBAccess::openSource not yet implemented");
+        owarn << "DBAccess::openSource not yet implemented" << oendl;
        return false;
    }
    virtual bool saveSource(QIODevice *) {
-        qWarning("DBAccess::saveSource(QString) not yet implemented");
+        owarn << "DBAccess::saveSource(QString) not yet implemented" << oendl;
        return false;
    }
 protected:
    DBStore *dstore;
    QString source_name;
 };
 class DBStore {
 public:
    DBStore();
    ~DBStore();
    bool openSource(QIODevice *, const QString &source);
    bool saveSource(QIODevice *, const QString &source);
    // Add an item
    void addItem(DataElem *);
    void addItemInternal(DataElem *);
-        void removeItem(DataElem *);
+    void removeItem(DataElem *);
    // Set the name of the database
    void setName(const QString &name);
    // Get the name of the database
    QString getName();
    KeyList *getKeys();
    void setKeys(KeyList *);
    /*! gets the number of fields defined in the database */
    inline int getNumFields() {
       return kRep->getNumFields();
    }
    /*! gets the index of a key given its name */
    inline int getKeyIndex(QString qs) {
        return kRep->getKeyIndex(qs);
    }
    /*! gets the type of a key given its index */
    inline TVVariant::KeyType getKeyType(int i) {
        return kRep->getKeyType(i);
    }
    /*! gets the name of a key given its index */
    inline QString getKeyName(int i) {
        return kRep->getKeyName(i);
    }
 // Access functions.. iterator type stuff
    void first();
    void last();
-        bool next();
+    bool next();
-        bool previous();
+    bool previous();
-        DataElem* getCurrentData();
+    DataElem* getCurrentData();
 private:
    /* does the work of freeing used memory */
    void freeTable();
-        QString name;
+    QString name;
    QVector<DataElem> master_table;
    DBAccess *archive;
    KeyList *kRep;
    unsigned int number_elems;
    unsigned int table_size; /* should always be a power of 2 */
-    bool full; /* since because we are using an int for indexing there is 
+    bool full; /* since because we are using an int for indexing there is
                  an upper limit on the number of items we can store. */
    unsigned int current_elem;
 };
 #endif
diff --git a/noncore/apps/tableviewer/ui/browsekeyentry.cpp b/noncore/apps/tableviewer/ui/browsekeyentry.cpp
index 42e24dd..6b78437 100644
--- a/noncore/apps/tableviewer/ui/browsekeyentry.cpp
+++ b/noncore/apps/tableviewer/ui/browsekeyentry.cpp
@@ -1,206 +1,205 @@
 /**********************************************************************
 ** 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 "browsekeyentry.h"
 #include "commonwidgets.h"
+#include <opie2/odebug.h>
+using namespace Opie::Core;
 #include <qtoolbutton.h>
 #include <qwidgetstack.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qpopupmenu.h>
 #include <qhbox.h>
 #include <qdatetime.h>
-#include <qheader.h>
-// For qWarning(const char *)
 /*!
    \class TVBrowseKeyEntry
    \brief a Widget used enter keys into the TVBrowseViewWidget
    The TVBrowseKeyEntry Widget provides the facility to enter
    various key types to be search on in the table.  The key can be changed
    and the entry field will update to the correct sort of widget appropriately
 */
 /*!
-    Constructs the widget 
+    Constructs the widget
 */
 TVBrowseKeyEntry::TVBrowseKeyEntry(QWidget *parent, const char *name, WFlags f)
    : QWidget(parent, name, f)
 {
    QHBoxLayout *h_layout = new QHBoxLayout(this);
    textKey = new QLineEdit(this, 0);
    intKey = new IntEdit(this, 0);
    dateKey = new DateEdit(this, 0);
    timeKey = new TimeEdit(this, 0);
    resetButton = new QPushButton(this, "reset");
    resetButton->setMinimumSize(QSize(50, 0));
    resetButton->setText(tr("Reset"));
    changeKeyButton = new QToolButton(this, "changekey");
    // TODO The icon stuff.
    changeKeyButton->setText(tr("key"));
    totalKeys = 0;
    ts = 0;
    keyMenu = new QPopupMenu(this, "keymenu");
    ws = new QWidgetStack(this, 0);
    ws->addWidget(textKey, TVVariant::String);
    ws->addWidget(intKey, TVVariant::Int);
    ws->addWidget(timeKey, TVVariant::Time);
    ws->addWidget(dateKey, TVVariant::Date);
    ws->raiseWidget(TVVariant::String);
-   
    // TODO connect slots and signals....
-    connect(changeKeyButton, SIGNAL(clicked()), 
+    connect(changeKeyButton, SIGNAL(clicked()),
            this, SLOT(changeKeyMenuSlot()));
-    connect(resetButton, SIGNAL(clicked()), 
+    connect(resetButton, SIGNAL(clicked()),
            textKey, SLOT(clear()));
-    connect(resetButton, SIGNAL(clicked()), 
+    connect(resetButton, SIGNAL(clicked()),
            intKey, SLOT(clear()));
-    connect(resetButton, SIGNAL(clicked()), 
+    connect(resetButton, SIGNAL(clicked()),
            dateKey, SLOT(clear()));
-    connect(resetButton, SIGNAL(clicked()), 
+    connect(resetButton, SIGNAL(clicked()),
            timeKey, SLOT(clear()));
    h_layout->addWidget(ws);
    h_layout->addWidget(resetButton);
    h_layout->addWidget(changeKeyButton);
-    connect(textKey, SIGNAL(textChanged(const QString&)), 
+    connect(textKey, SIGNAL(textChanged(const QString&)),
            this, SLOT(searchOnText()));
-    connect(intKey, SIGNAL(valueChanged(int)), 
+    connect(intKey, SIGNAL(valueChanged(int)),
            this, SLOT(searchOnText()));
-    connect(dateKey, SIGNAL(valueChanged(const QDate&)), 
+    connect(dateKey, SIGNAL(valueChanged(const QDate&)),
            this, SLOT(searchOnText()));
-    connect(timeKey, SIGNAL(valueChanged(const QTime&)), 
+    connect(timeKey, SIGNAL(valueChanged(const QTime&)),
            this, SLOT(searchOnText()));
 }
 /*!
-    Destructs the widget 
+    Destructs the widget
 */
 TVBrowseKeyEntry::~TVBrowseKeyEntry()
 {
 }
 /*!
    Changes which key the user intends to search on
    \param id_param the index of the key future searches should be base on
 */
 void TVBrowseKeyEntry::changeKeySlot(int id_param)
 {
    if(ts) {
        emit sortChanged(id_param);
        ws->raiseWidget(ts->kRep->getKeyType(ts->current_column));
    }
 }
 /*!
    Opens the change key menu
 */
 void TVBrowseKeyEntry::changeKeyMenuSlot()
 {
-    if(ts) 
+    if(ts)
        keyMenu->exec(changeKeyButton->mapToGlobal(QPoint(0,0)));
 }
 void TVBrowseKeyEntry::setTableState(TableState *t) {
    ts = t;
 }
 void TVBrowseKeyEntry::rebuildKeys() {
    int i;
    if (!ts) return;
    if (!ts->kRep) return;
    /* clear the old */
    keyMenu->clear();
    KeyListIterator it(*ts->kRep);
    for (i = 0; i < ts->kRep->getNumFields(); i++) {
-        keyMenu->insertItem(it.current()->name(), this, 
+        keyMenu->insertItem(it.current()->name(), this,
                SLOT(changeKeySlot(int)), 0, i);
        keyMenu->setItemParameter(i, it.currentKey());
        ++it;
    }
 }
 void TVBrowseKeyEntry::reset()
 {
    textKey->clear();
    intKey->clear();
    dateKey->clear();
    timeKey->clear();
    keyMenu->clear();
 }
 /*!
-    Searches on the current value of the key entry provided that the 
+    Searches on the current value of the key entry provided that the
-    current key is of type text WARNING, TODO fix memory leaks 
+    current key is of type text WARNING, TODO fix memory leaks
 */
 void TVBrowseKeyEntry::searchOnText()
 {
    TVVariant sendkey;
    if (!ts)
        return;
    switch(ts->kRep->getKeyType(ts->current_column)) {
        case TVVariant::String:
            sendkey = TVVariant(QString(textKey->text()));
            break;
        case TVVariant::Int: {
            sendkey = TVVariant(intKey->value());
            break;
        }
        case TVVariant::Time: {
            sendkey = TVVariant(QTime(timeKey->time()));
            break;
        }
        case TVVariant::Date: {
            sendkey = TVVariant(QDate(dateKey->date()));
            break;
        }
-        case TVVariant::Invalid:
+    case TVVariant::Invalid:
-            break;
+        break;
        default:
-            qWarning("TVBrowseKeyEntry::searchOnText() "
+            owarn << "TVBrowseKeyEntry::searchOnText() cannot work out data type" << oendl;
-                     "cannot work out data type");
            return;
    }
    emit searchOnKey(ts->current_column, sendkey);
 }
 /*! \fn void TVBrowseKeyEntry::searchOnKey(int currentKeyId, TVVariant)
    This signal indicates that a search on key index currentKeyId should be
    done searching for the value v.
-*/ 
+*/
diff --git a/noncore/apps/tableviewer/ui/filterkeyentry.cpp b/noncore/apps/tableviewer/ui/filterkeyentry.cpp
index d108fbd..4d74d6b 100644
--- a/noncore/apps/tableviewer/ui/filterkeyentry.cpp
+++ b/noncore/apps/tableviewer/ui/filterkeyentry.cpp
@@ -1,46 +1,51 @@
 /**********************************************************************
 ** 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 "filterkeyentry.h"
 #include "commonwidgets.h"
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #include <qwidgetstack.h>
 #include <qcombobox.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qsizepolicy.h>
 #include <qdatetime.h>
 #include <qhbox.h>
 TVFilterKeyEntry::TVFilterKeyEntry(QWidget *parent, const char *name, WFlags f)
    : QWidget(parent, name, f)
 {
    int stack_elem = 0;
    layout = new QHBoxLayout(this, 0);
    layout->setSpacing(0);
    layout->setMargin(0);
    textEntry = new QHBox(this, 0);
    textEntry->setSpacing(0);
    textEntry->setMargin(0);
    intEntry = new QHBox(this, 0);
    intEntry->setSpacing(0);
    intEntry->setMargin(0);
@@ -77,76 +82,76 @@ TVFilterKeyEntry::TVFilterKeyEntry(QWidget *parent, const char *name, WFlags f)
    /* Build the time combo list */
    timeCombo->insertItem("less than");
    timeCombo->insertItem("more than");
    timeCombo->insertItem("equal to");
    dateCombo = new QComboBox(dateEntry, 0);
    dateKey = new DateEdit(dateEntry, 0);
    /* Build the date combo list */
    dateCombo->insertItem("less than");
    dateCombo->insertItem("more than");
    dateCombo->insertItem("equal to");
    ts = 0;
    ws = new QWidgetStack(this, 0);
    ws->setMargin(0);
    ws->addWidget(textEntry, TVVariant::String);
    ws->addWidget(intEntry, TVVariant::Int);
    ws->addWidget(timeEntry, TVVariant::Time);
    ws->addWidget(dateEntry, TVVariant::Date);
    /* connect the signals down */
-    connect(textKey, SIGNAL(textChanged(const QString&)), 
+    connect(textKey, SIGNAL(textChanged(const QString&)),
            this, SIGNAL(valueChanged()));
-    connect(intKey, SIGNAL(valueChanged(int)), 
+    connect(intKey, SIGNAL(valueChanged(int)),
            this, SIGNAL(valueChanged()));
-    connect(dateKey, SIGNAL(valueChanged(const QDate&)), 
+    connect(dateKey, SIGNAL(valueChanged(const QDate&)),
            this, SIGNAL(valueChanged()));
-    connect(timeKey, SIGNAL(valueChanged(const QTime&)), 
+    connect(timeKey, SIGNAL(valueChanged(const QTime&)),
            this, SIGNAL(valueChanged()));
    connect(intCombo, SIGNAL(activated(int)), this, SIGNAL(valueChanged()));
    connect(textCombo, SIGNAL(activated(int)), this, SIGNAL(valueChanged()));
    connect(timeCombo, SIGNAL(activated(int)), this, SIGNAL(valueChanged()));
    connect(dateCombo, SIGNAL(activated(int)), this, SIGNAL(valueChanged()));
    ws->raiseWidget(TVVariant::String);
    layout->addWidget(ws);
    current_type = TVVariant::String;
 }
 /*!
-    Destructs the widget 
+    Destructs the widget
 */
 TVFilterKeyEntry::~TVFilterKeyEntry()
 {
 }
-void TVFilterKeyEntry::setKey(int i) 
+void TVFilterKeyEntry::setKey(int i)
 {
    if (!ts) return;
    if (!ts->kRep) return;
    /* set up to raise appropriate widget set */
    if (current_type != ts->kRep->getKeyType(i)) {
        current_type = ts->kRep->getKeyType(i);
        ws->raiseWidget(current_type);
    }
 }
 void TVFilterKeyEntry::setTableState(TableState *t) {
    int i;
    ts = t;
    if(!t) return;
    if (!t->kRep)
        return;
    if (t->kRep->getNumFields() < 1)
        return;
    setKey(0);
    /* set up the the menu stuff.. */
 }
@@ -162,47 +167,46 @@ CmpType TVFilterKeyEntry::getCompareType()
            CmpType k = (CmpType) intCombo->currentItem();
            return k;
        }
        case TVVariant::Time: {
            CmpType k = (CmpType) timeCombo->currentItem();
            return k;
        }
        case TVVariant::Date: {
            CmpType k = (CmpType) dateCombo->currentItem();
            return k;
        }
        default:
            break;
    }
    return ct_equal;
 }
 /* MUST return a valid pointer */
 TVVariant TVFilterKeyEntry::getCompareValue()
 {
    TVVariant sendkey;
    int tmp;
    switch(current_type) {
-        case TVVariant::String: 
+        case TVVariant::String:
-            sendkey = TVVariant(QString(textKey->text())); 
+            sendkey = TVVariant(QString(textKey->text()));
-            break; 
+            break;
-        case TVVariant::Int: { 
+        case TVVariant::Int: {
            sendkey = TVVariant(intKey->value());
-            break; 
+            break;
-        } 
+        }
        case TVVariant::Time: {
-            sendkey = TVVariant(QTime(timeKey->time())); 
+            sendkey = TVVariant(QTime(timeKey->time()));
-            break; 
+            break;
        }
        case TVVariant::Date: {
-            sendkey = TVVariant(QDate(dateKey->date())); 
+            sendkey = TVVariant(QDate(dateKey->date()));
-            break; 
+            break;
        }
        default: {
            sendkey = TVVariant(0);
-            qWarning("TVFilterKeyEntry::getCompareValue() "
+            owarn << "TVFilterKeyEntry::getCompareValue() cannot work out data type" << oendl;
-                     "cannot work out data type");
        }
    }
    return sendkey;
 }
diff --git a/noncore/apps/tableviewer/ui/tvfilterview.cpp b/noncore/apps/tableviewer/ui/tvfilterview.cpp
index 22f1fb7..198c8b5 100644
--- a/noncore/apps/tableviewer/ui/tvfilterview.cpp
+++ b/noncore/apps/tableviewer/ui/tvfilterview.cpp
@@ -1,59 +1,65 @@
 /**********************************************************************
 ** 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 "tvfilterview.h"
+/* OPIE */
+#include <opie2/odebug.h>
+#include <qpe/qpeapplication.h>
+using namespace Opie::Core;
+/* QT */
 #include <qtoolbutton.h>
 #include <qcombobox.h>
 #include <qlistview.h>
 #include <qlayout.h>
 #include <qheader.h>
 #include <qpushbutton.h>
 #include <qlabel.h>
-#include <qpe/qpeapplication.h>
 TVFilterView::TVFilterView(TableState *t, QWidget* parent,
                           const char *name, WFlags fl ) : QDialog(parent, name, TRUE, fl)
 {
-    if ( !name ) 
+    if ( !name )
-        setName( "Filter View" );
+    setName( "Filter View" );
    QVBoxLayout *vlayout = new QVBoxLayout(this);
    display = new QListView(this, "display");
    display->addColumn("Key");
    display->addColumn("Constraint");
    display->addColumn("Value");
    display->header()->setClickEnabled(FALSE);
    display->header()->setResizeEnabled(FALSE);
    vlayout->addWidget(display);
    QHBoxLayout *hlayout = new QHBoxLayout;
    hlayout->addItem(new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum));
    newFilterButton = new QPushButton(this, "new Filter");
    newFilterButton->setMaximumSize(QSize(50, 32767));
    newFilterButton->setText("New");
    hlayout->addWidget(newFilterButton);
    deleteFilterButton = new QPushButton(this, "delete Filter");
    deleteFilterButton->setMaximumSize(QSize(50, 32767));
    deleteFilterButton->setText("Delete");
    hlayout->addWidget(deleteFilterButton);
@@ -67,240 +73,239 @@ TVFilterView::TVFilterView(TableState *t, QWidget* parent,
    QHBoxLayout *hlayout2 = new QHBoxLayout;
    keyNameCombo = new QComboBox(FALSE, this, "key name");
    keyNameCombo->setEnabled(FALSE);
    hlayout2->addWidget(keyNameCombo);
    QLabel *label = new QLabel(this);
    label->setText("has value");
    hlayout2->addWidget(label);
    keyEntry = new TVFilterKeyEntry(this, "key entry");
    keyEntry->setEnabled(FALSE);
    vlayout->addLayout(hlayout2);
    vlayout->addWidget(keyEntry);
    connect(newFilterButton, SIGNAL( clicked() ), this, SLOT( newTerm() ));
    connect(deleteFilterButton, SIGNAL( clicked() ), this, SLOT( deleteTerm()));
    connect(clearFilterButton, SIGNAL( clicked() ), this, SLOT( clearTerms()));
    connect(keyEntry, SIGNAL(valueChanged()), this, SLOT( updateTerm() ));
    connect(keyNameCombo, SIGNAL(activated(int)), this, SLOT( updateTerm() ));
-    connect(display, SIGNAL(selectionChanged(QListViewItem*)), this, 
+    connect(display, SIGNAL(selectionChanged(QListViewItem*)), this,
-            SLOT(setTerm(QListViewItem*)));
+        SLOT(setTerm(QListViewItem*)));
    ts = t;
    current = 0;
    terms.setAutoDelete(true);
    do_filter = false;
 #ifdef Q_WS_QWS
    QPEApplication::showDialog( this );
 #endif
 }
 /*!
-    Destroys the TVFilterView widget 
+    Destroys the TVFilterView widget
 */
 TVFilterView::~TVFilterView()
 {
 }
 void TVFilterView::rebuildData()
 {
 }
 void TVFilterView::reset()
 {
    keyNameCombo->clear();
    keyIds.clear();
 }
-void TVFilterView::rebuildKeys() 
+void TVFilterView::rebuildKeys()
 {
    int i;
    if (!ts) return;
    if(!ts->kRep) return;
    keyEntry->setTableState(ts);
-    
    /* set up the list of keys that can be compared on */
    keyNameCombo->clear();
    KeyListIterator it(*ts->kRep);
    i = 0;
    while(it.current()) {
-            if(ts->kRep->validIndex(it.currentKey())) {
+        if(ts->kRep->validIndex(it.currentKey())) {
-                        keyNameCombo->insertItem(it.current()->name());
+            keyNameCombo->insertItem(it.current()->name());
-                        keyIds.insert(i, it.currentKey());
+            keyIds.insert(i, it.currentKey());
-                        ++i;
+            ++i;
-                }
+        }
-                ++it;
+        ++it;
    }
 }
 bool TVFilterView::passesFilter(DataElem *d) {
    if (!filterActive()) return true;
    FilterTerm *t;
-    
    for (t = terms.first(); t != 0; t = terms.next() ) {
        /* check against filter */
        switch(t->ct) {
            case ct_less:
                if (!d->lessThan(t->keyIndex, t->value))
                    return false;
                break;
            case ct_more:
                if (!d->moreThan(t->keyIndex, t->value))
                    return false;
                break;
            case ct_equal:
                if (!d->equalTo(t->keyIndex, t->value))
                    return false;
                break;
            case ct_contains:
                if (!d->contains(t->keyIndex, t->value))
                    return false;
                break;
            case ct_startswith:
                if (!d->startsWith(t->keyIndex, t->value))
                    return false;
                break;
            case ct_endswith:
                if (!d->endsWith(t->keyIndex, t->value))
                    return false;
                break;
            default:
-                qWarning("TVFilterView::passesFilter() "
+                owarn << "TVFilterView::passesFilter() unrecognized filter type" << oendl;
-                         "unrecognized filter type");
                return false;
        }
    }
    return true;
 }
 bool TVFilterView::filterActive() const
 {
    /* when button operated, also check the do_filter value
    return do_filter;
    */
    if (terms.isEmpty())
        return false;
    return true;
 }
 /* SLOTS */
-void TVFilterView::newTerm() 
+void TVFilterView::newTerm()
 {
    if (!ts) return;
    FilterTerm *term = new FilterTerm;
    current = term;
    term->view = 0;
    updateTerm();
    display->setSelected(term->view, true);
    terms.append(term);
    keyEntry->setEnabled(true);
    keyNameCombo->setEnabled(true);
 }
-void TVFilterView::updateTerm() 
+void TVFilterView::updateTerm()
 {
    FilterTerm *term;
    /* Read the widget values (keyname, compare type, value)
     * and build the lists */
    if (!ts) return;
    if (!current) return;
    QString keyString;
    QString cmpString;
    QString vString;
    term = current;
    /* create new list item, set initial values, enable widgets */
    term->keyIndex = keyIds[keyNameCombo->currentItem()];
    keyEntry->setKey(term->keyIndex); /* so the next two items make sense */
    term->ct = keyEntry->getCompareType(),
    term->value = keyEntry->getCompareValue();
-   
    keyString = keyNameCombo->currentText();
    switch(term->ct) {
        case ct_less:
            cmpString = " less than ";
            break;
        case ct_more:
            cmpString = " more than ";
            break;
        case ct_equal:
            cmpString = " equal to ";
            break;
        case ct_contains:
            cmpString = " containing ";
            break;
        case ct_startswith:
            cmpString = " starting with ";
            break;
        case ct_endswith:
            cmpString = " ending with ";
            break;
        default:
            cmpString = " ERROR ";
    }
    vString = term->value.toString();
    /* remove old view */
-    if (term->view) 
+    if (term->view)
        delete(term->view);
    term->view = new QListViewItem(display, 0, keyString, cmpString, vString);
    display->setSelected(term->view, true);
 }
 /* deletes current term */
-void TVFilterView::deleteTerm() 
+void TVFilterView::deleteTerm()
 {
    if(!current) return;
    if (current->view)
        delete(current->view);
    terms.removeRef(current);
    current = terms.first();
    if(terms.isEmpty()) {
        keyEntry->setEnabled(false);
        keyNameCombo->setEnabled(false);
    }
 }
 /* clears all terminations */
-void TVFilterView::clearTerms() 
+void TVFilterView::clearTerms()
 {
    while(current)
        deleteTerm();
 }
 void TVFilterView::setTerm(QListViewItem *target)
 {
-    /* Iterate through the list to find item with view=target.. 
+    /* Iterate through the list to find item with view=target..
     * set as current, delete */
    FilterTerm *term = current;
    for (current = terms.first(); current != 0; current = terms.next() )
        if (current->view == target)
            break;
    if (!current) {
-        current = term; 
+        current = term;
    }
 }
diff --git a/noncore/apps/tinykate/libkate/kateconfig.cpp b/noncore/apps/tinykate/libkate/kateconfig.cpp
index 782b629..4b8ce78 100644
--- a/noncore/apps/tinykate/libkate/kateconfig.cpp
+++ b/noncore/apps/tinykate/libkate/kateconfig.cpp
@@ -3,48 +3,49 @@
 **
 ** 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.
 **
 **********************************************************************/
 #define QTOPIA_INTERNAL_LANGLIST
 #include "kateconfig.h"
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/global.h>
+using namespace Opie::Core;
 /* QT */
 #include <qdir.h>
 #include <qmessagebox.h>
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
 #include <qtextcodec.h>
 #endif
 #include <qtextstream.h>
 /* STD */
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
 /*!
  \internal
 */
 QString KateConfig::configFilename(const QString& name, Domain d)
 {
    switch (d) {
    case File:
@@ -535,50 +536,49 @@ void KateConfig::write( const QString &fn )
    QCString cstr;
    QMap< QString, KateConfigGroup >::Iterator g_it = groups.begin();
    for ( ; g_it != groups.end(); ++g_it ) {
    str += "[" + g_it.key() + "]\n";
    KateConfigGroup::Iterator e_it = ( *g_it ).begin();
    for ( ; e_it != ( *g_it ).end(); ++e_it )
        str += e_it.key() + " = " + *e_it + "\n";
    }
    cstr = str.utf8();
    int total_length;
    total_length = f.writeBlock( cstr.data(), cstr.length() );
    if ( total_length != int(cstr.length()) ) {
    QMessageBox::critical( 0, QObject::tr("Out of Space"),
                   QObject::tr("There was a problem creating\nKateConfiguration Information \nfor this program.\n\nPlease free up some space and\ntry again.") );
    f.close();
    QFile::remove( strNewFile );
    return;
    }
    f.close();
    // now rename the file...
    if ( rename( strNewFile, filename ) < 0 ) {
-    qWarning( "problem renaming the file %s to %s", strNewFile.latin1(),
+    owarn << "problem renaming the file " << strNewFile.latin1() << " to " << filename.latin1() << oendl;
-          filename.latin1() );
    QFile::remove( strNewFile );
    }
 }
 /*!
  Returns whether the KateConfig is in a valid state.
 */
 bool KateConfig::isValid() const
 {
    return groups.end() != git;
 }
 /*!
  \internal
 */
 void KateConfig::read()
 {
    changed = FALSE;
    if ( !QFileInfo( filename ).exists() ) {
    git = groups.end();
    return;
    }
diff --git a/noncore/apps/zsafe/main.cpp b/noncore/apps/zsafe/main.cpp
index 4fe319b..5f48f77 100644
--- a/noncore/apps/zsafe/main.cpp
+++ b/noncore/apps/zsafe/main.cpp
@@ -1,111 +1,116 @@
 /*
 ** Author: Carsten Schneider <CarstenSchneider@t-online.de>
 **
 ** $Id$
 **
 ** Homepage: http://home.t-online.de/home/CarstenSchneider/zsafe/index.html
 */
 #include "zsafe.h"
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #ifdef DESKTOP
 #include <qapplication.h>
 #else
 #include <qpe/qpeapplication.h>
 #endif
+/* STD */
 #include <stdio.h>
 #include <signal.h>
 ZSafe *zs;
 #ifdef DESKTOP
 QApplication   *appl;
 #else
 QPEApplication *appl;
 #endif
 int DeskW;
 int DeskH;
 void suspend (int signum)
 {
   printf ("Suspend signal %d received\n", signum);
 }
 void resume (int signum)
 {
   printf ("Resume signal %d received\n", signum);
   zs->resume(signum);
 }
 int main( int argc, char ** argv )
 {
 #ifndef WIN32
    // install signal handler
    signal (SIGSTOP, suspend);
 #endif
 #ifdef DESKTOP
    QApplication a( argc, argv );
 #else
    QPEApplication a( argc, argv );
 #endif
    appl = &a;
 #ifdef DESKTOP
    if (argc >= 3)
    {
 #ifndef WIN32
       DeskW = atoi(argv[1]);
       DeskH = atoi(argv[2]);
 #else
-           int w, h;
+       int w, h;
-           sscanf (argv[1], "%d", &w);
+       sscanf (argv[1], "%d", &w);
-           sscanf (argv[2], "%d", &h);
+       sscanf (argv[2], "%d", &h);
-           DeskW = w;
+       DeskW = w;
       DeskH = h;
 #endif
    }
    else
    {
       DeskW = 600;
       DeskH = 400;
    }
 #else
    DeskW = a.desktop()->width();
    DeskH = a.desktop()->height();
-    char buf[128];
+    owarn << "Width: " << DeskW << " Height: " << DeskH << oendl;
-    sprintf (buf, "Width: %d Height: %d\n", DeskW, DeskH);
-    qWarning (buf);
 #ifdef JPATCH_HDE
    // nothings
 #else
-    if (DeskW > 240) 
+    if (DeskW > 240)
    {
       DeskW -= 20;
       DeskH += 25;
-       sprintf (buf, "Changed width: %d Height: %d\n", DeskW, DeskH);
+       owarn << "Changed width: " << DeskW << " Height: " << DeskH << oendl;
-       qWarning (buf);
    }
 #endif
 #endif
    ZSafe mw;
    zs = &mw;
 #ifndef WIN32
    signal (SIGCONT, resume);
 #endif
 #ifdef DESKTOP
    a.setMainWidget(&mw);
    mw.show();
 #else
    // a.showMainWidget( &mw );
    a.showMainDocumentWidget( &mw );
 #endif
    int ret = a.exec();
    return ret;
 }
diff --git a/noncore/apps/zsafe/zlistview.cpp b/noncore/apps/zsafe/zlistview.cpp
index ba02a15..7d0b8c2 100644
--- a/noncore/apps/zsafe/zlistview.cpp
+++ b/noncore/apps/zsafe/zlistview.cpp
@@ -1,36 +1,39 @@
 /*
 ** $Id$
 */
 #include "zlistview.h"
-#include <stdio.h>
 #include "zsafe.h"
+/* OPIE */
+//#include <opie2/odebug.h>
+/* STD */
+#include <stdio.h>
 ZListView::ZListView (ZSafe *zsafe, const char *id) : QListView(zsafe, id)
 {
   zs = zsafe;
 }
 ZListView::~ZListView()
 {
 }
 void ZListView::keyPressEvent ( QKeyEvent *e )
 {
 /*
-   char buf[64];
+   owarn << "key: " << e->key() << oendl;
-   sprintf (buf, "key: %d\n", e->key());
-   qWarning (buf);
 */
   switch (e->key())
   {
      case 32: // middle cursor key pressed
         zs->showInfo (zs->selectedItem);
         break;
      default:
         QListView::keyPressEvent( e );
   }
 }
diff --git a/noncore/apps/zsafe/zsafe.cpp b/noncore/apps/zsafe/zsafe.cpp
index 6ff05ac..ca3ff52 100644
--- a/noncore/apps/zsafe/zsafe.cpp
+++ b/noncore/apps/zsafe/zsafe.cpp
@@ -860,126 +860,126 @@ void ZSafe::findPwd()
       dialog->NameField->setText(lastSearchedName);
    else
       dialog->NameField->setText("");
    if (lastSearchedUsername)
       dialog->UsernameField->setText(lastSearchedUsername);
    else
       dialog->UsernameField->setText("");
    if (lastSearchedComment)
       dialog->CommentField->setText(lastSearchedComment);
    else
       dialog->CommentField->setText("");
    DialogCode result = (DialogCode) dialog->exec();
 #ifdef DESKTOP
       result = Accepted;
 #endif
    QString name;
    QString username;
    QString comment;
    if (result == Accepted)
    {
       name = dialog->NameField->text();
       username = dialog->UsernameField->text();
       comment = dialog->CommentField->text();
-       qWarning (name);
+       owarn << name << oendl;
    }
    else
    {
       delete dialog;
       return;
    }
    if (!name.isEmpty() && name != lastSearchedName ||
        lastSearchedName.isEmpty() && !name.isEmpty())
    {
       // set search at the beginning if a new name is given
       lastSearchedCategory = NULL;
       lastSearchedItem = NULL;
    }
    lastSearchedName = name;
    if (!username.isEmpty() && username != lastSearchedUsername ||
        lastSearchedUsername.isEmpty() && !username.isEmpty())
    {
       // set search at the beginning if a new name is given
       lastSearchedCategory = NULL;
       lastSearchedItem = NULL;
    }
    lastSearchedUsername = username;
    if (!comment.isEmpty() && comment != lastSearchedComment ||
        lastSearchedComment.isEmpty() && !comment.isEmpty())
    {
       // set search at the beginning if a new name is given
       lastSearchedCategory = NULL;
       lastSearchedItem = NULL;
    }
    lastSearchedComment = comment;
    ListView->clearSelection();
    bool found=FALSE;
    // step through all categories
    QListViewItem *i;
    if (lastSearchedCategory)
       i = lastSearchedCategory;
     else
       i = ListView->firstChild();
    for (;
         i != NULL;
         i = i->nextSibling())
    {
-       qWarning (i->text(0));
+       owarn << i->text(0) << oendl;
       i->setSelected(FALSE);
       // step through all subitems
       QListViewItem *si;
       if (lastSearchedItem)
          si = lastSearchedItem;
       else
          si = i->firstChild();
       // for (si = i->firstChild();
       for (;
            si != NULL;
            si = si->nextSibling())
       {
-          qWarning (si->text(0));
+          owarn << si->text(0) << oendl;
          if (si->isSelected())
             si->setSelected(FALSE);
          // ListView->repaintItem(si);
          bool n=TRUE;
          bool u=TRUE;
          bool c=TRUE;
          if (!name.isEmpty())
             n = (si->text(0)).contains (name, FALSE);
          if (!username.isEmpty())
             u = (si->text(1)).contains (username, FALSE);
          if (!comment.isEmpty())
             c = (si->text(3)).contains (comment, FALSE);
          if ((n && u && c ) && !found)
          {
-             qWarning ("Found");
+             owarn << "Found" << oendl;
             selectedItem = si;
             si->setSelected(TRUE);
             ListView->setCurrentItem(si);
             ListView->ensureItemVisible(si);
             ListView->triggerUpdate();
             lastSearchedCategory = i;
             // set to the next item
             lastSearchedItem = si->nextSibling();
             if (!lastSearchedItem)
             {
                // no next item within category -> set next category
                lastSearchedCategory = i->nextSibling();
                if (!lastSearchedCategory)
                   lastSearchedItem = NULL; // END
             }
             found = TRUE;
             delete dialog;
             update();
             return;
          }
       }
       lastSearchedCategory = i->nextSibling();
@@ -1207,224 +1207,221 @@ void ZSafe::removeAsciiFile()
                       QString::null,
                       mimeTypes,
                       this,
                       tr ("Remove text file"));
 #else
  QString fn = ScQtFileEdit::getOpenFileName(this,
                       tr ("Remove text file"),
                       QDir::homeDirPath() + "/Documents/application/zsafe",
                       "*.txt");
 #endif
 #else
  QString fn = QFileDialog::getOpenFileName(
                QDir::homeDirPath() + "/Documents/application/zsafe",
                    "ZSafe (*.txt)",
                    this,
                    "ZSafe File Dialog"
                    "Choose a text file" );
 #endif
  if (fn && fn.length() > 0 )
  {
    QFile f( fn );
    if ( !f.remove() )
    {
-        qWarning( QString("Could not remove file %1").arg(fn),
+        owarn << "Could not remove file " << fn << oendl;
-                      2000 );
        QMessageBox::critical( 0, tr("ZSafe"),
                  tr("Could not remove text file.") );
        return;
    }
  }
 }
 void ZSafe::writeAllEntries()
 {
   if (filename.isEmpty())
   {
       QMessageBox::critical( 0, tr("ZSafe"),
         tr("No document defined.\nYou have to create a new document"));
       return;
   }
   // open the file dialog
 #ifndef DESKTOP
 #ifndef NO_OPIE
   QMap<QString, QStringList> mimeTypes;
   mimeTypes.insert(tr("All"), QStringList() );
   mimeTypes.insert(tr("Text"), "text/*" );
   QString fn = OFileDialog::getSaveFileName( OFileSelector::EXTENDED_ALL,
                       QDir::homeDirPath() + "/Documents/application/zsafe",
                       QString::null,
                       mimeTypes,
                       this,
                       tr ("Export text file"));
 #else
   QString fn = ScQtFileEdit::getSaveAsFileName(this,
                       tr ("Export text file"),
                       QDir::homeDirPath() + "/Documents/application/zsafe",
                       "*.txt");
 #endif
 #else
   QString fn = QFileDialog::getSaveFileName(
                QDir::homeDirPath() + "/Documents/application/zsafe",
                    "ZSafe (*.txt)",
                    this,
                    "ZSafe File Dialog"
                    "Choose a text file" );
 #endif
   // open the new document
   if (fn && fn.length() > 0 )
   {
    QFile f( fn );
    if ( !f.open( IO_WriteOnly ) ) {
-        qWarning( QString("Could not write to file %1").arg(fn),
+        owarn << "Could not write to file " << fn << oendl;
-                      2000 );
        QMessageBox::critical( 0, "ZSafe",
                  QString("Could not export to text file.") );
        return;
    }
    QTextStream t( &f );
    QListViewItem *i;
    // step through all categories
    for (i = ListView->firstChild();
         i != NULL;
         i = i->nextSibling())
    {
       // step through all subitems
       QListViewItem *si;
       for (si = i->firstChild();
            si != NULL;
            si = si->nextSibling())
       {
          QString oneEntry;
          oneEntry += "\"";
          oneEntry += i->text(0);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(0);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(1);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(2);
          oneEntry += "\";";
          oneEntry += "\"";
          QString comment = si->text(3);
          comment.replace (QRegExp("\n"), "<br>");
          oneEntry += comment;
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(4);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(5);
          oneEntry += "\"";
-          // qWarning (oneEntry);
+          // owarn << oneEntry << oendl;
          t << oneEntry << endl;
-          // qWarning (si->text(0));
+          // owarn << si->text(0) << oendl;
       }
    }
    f.close();
   }
 }
 void ZSafe::readAllEntries()
 {
   if (filename.isEmpty())
   {
       QMessageBox::critical( 0, tr("ZSafe"),
         tr("No document defined.\nYou have to create a new document"));
       return;
   }
  // open the file dialog
 #ifndef DESKTOP
 #ifndef NO_OPIE
   QMap<QString, QStringList> mimeTypes;
   mimeTypes.insert(tr("All"), QStringList() );
   mimeTypes.insert(tr("Text"), "text/*" );
   QString fn = OFileDialog::getOpenFileName( OFileSelector::EXTENDED_ALL,
                       QDir::homeDirPath() + "/Documents/application/zsafe",
                       QString::null,
                       mimeTypes,
                       this,
                       tr ("Import text file"));
 #else
  QString fn = ScQtFileEdit::getOpenFileName(this,
                       tr ("Import text file"),
                       QDir::homeDirPath() + "/Documents/application/zsafe",
                       "*.txt");
 #endif
 #else
  QString fn = QFileDialog::getOpenFileName(
                QDir::homeDirPath() + "/Documents/application/zsafe",
                    "ZSafe (*.txt)",
                    this,
                    "ZSafe File Dialog"
                    "Choose a text file" );
 #endif
  if (fn && fn.length() > 0 )
  {
   QFile f( fn );
   if ( !f.open( IO_ReadOnly ) )
   {
-      qWarning( QString("Could not read file %1").arg(fn),
+      owarn << "Could not read file " << fn << oendl;
-                      2000 );
      QMessageBox::critical( 0, "ZSafe",
                  QString("Could not import text file.") );
      return;
   }
   modified = true;
   // clear the password list
   selectedItem = NULL;
   QListViewItem *i;
   // step through all categories
   for (i = ListView->firstChild();
        i != NULL;
        i = i->nextSibling())
   {
      // step through all subitems
      QListViewItem *si;
      for (si = i->firstChild();
           si != NULL; )
           // si = si->nextSibling())
      {
          QListViewItem *_si = si;
          si = si->nextSibling();
          i->takeItem(_si); // remove from view list
          if (_si) delete _si;
      }
   }
-   qWarning ("ReadAllEntries(): ");
+   owarn << "ReadAllEntries(): " << oendl;
   QTextStream t(&f);
   while ( !t.eof() )
   {
      QString s = t.readLine();
      s.replace (QRegExp("\";\""), "\"|\"");
      // char buffer[1024];
 #ifndef WIN32
      char buffer[s.length()+1];
 #else
      char buffer[4048];
 #endif
      /* modify QString -> QCString::utf8 */
      strcpy (buffer, s.utf8());
      QString name;
      QString user;
      QString password;
      QString comment;
      QString field5="";
      QString field6="";
@@ -1533,133 +1530,131 @@ void ZSafe::readAllEntries()
            c1->setIcon (*getPredefinedIcon(category));
         }
         c1->setListItem (catI);
         c1->initListItem();
         categories.insert (c1->getCategoryName(), c1);
      }
   }
   f.close();
  }
  else
  {
  }
 }
 #ifdef UNUSED
 void ZSafe::writeAllEntries()
 {
    // open the file for writing
    QString fn = filename + ".txt";
    QFile f( fn );
    if ( !f.open( IO_WriteOnly ) ) {
-        qWarning( QString("Could not write to file %1").arg(fn),
+        owarn << "Could not write to file " << fn << oendl;
-                      2000 );
        QMessageBox::critical( 0, tr("ZSafe"),
                  tr("Could not export to text file.") );
        return;
    }
    QTextStream t( &f );
    QListViewItem *i;
    // step through all categories
    for (i = ListView->firstChild();
         i != NULL;
         i = i->nextSibling())
    {
       // step through all subitems
       QListViewItem *si;
       for (si = i->firstChild();
            si != NULL;
            si = si->nextSibling())
       {
          QString oneEntry;
          oneEntry += "\"";
          oneEntry += i->text(0);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(0);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(1);
          oneEntry += "\";";
          oneEntry += "\"";
          oneEntry += si->text(2);
          oneEntry += "\";";
          oneEntry += "\"";
          // oneEntry += si->text(3);
          QString comment = si->text(3);
          comment.replace (QRegExp("\n"), "<br>");
          oneEntry += comment;
          oneEntry += "\"";
-          // qWarning (oneEntry);
+          // owarn << oneEntry << oendl;
          t << oneEntry << endl;
-          // qWarning (si->text(0));
+          // owarn << si->text(0) << oendl;
       }
    }
    f.close();
 }
 void ZSafe::readAllEntries()
 {
   QString fn = filename + ".txt";
   QFile f( fn );
   if ( !f.open( IO_ReadOnly ) )
   {
-      qWarning( QString("Could not read file %1").arg(fn),
+      owarn << "Could not read file " << fn << oendl;
-                      2000 );
      QMessageBox::critical( 0, tr("ZSafe"),
                  tr("Could not import text file.") );
      return;
   }
   modified = true;
   // clear the password list
   selectedItem = NULL;
   QListViewItem *i;
   // step through all categories
   for (i = ListView->firstChild();
        i != NULL;
        i = i->nextSibling())
   {
      // step through all subitems
      QListViewItem *si;
      for (si = i->firstChild();
           si != NULL; )
           // si = si->nextSibling())
      {
          QListViewItem *_si = si;
          si = si->nextSibling();
          i->takeItem(_si); // remove from view list
          if (_si) delete _si;
      }
   }
-   qWarning ("ReadAllEntries(): ");
+   owarn << "ReadAllEntries(): " << oendl;
   QTextStream t(&f);
   while ( !t.eof() )
   {
      QString s = t.readLine();
      s.replace (QRegExp("\";\""), "\"|\"");
      // char buffer[1024];
      int len=s.length()+1;
 #ifdef WIN32
      char buffer[512];
 #else
      char buffer[len];
 #endif
      strcpy (buffer, s);
      QString name;
      QString user;
      QString password;
      QString comment;
      // separete the entries
      char *i = strtok (buffer, "|");
      QString category(&i[1]);
      category.truncate(category.length() -1);
@@ -1741,49 +1736,49 @@ void ZSafe::readAllEntries()
               QImage img = pix->convertToImage();
               pix->convertFromImage(img.smoothScale(14,14));
               c1->setIconName (icon);
               c1->setIcon (*pix);
               isIconAv = true;
            }
         }
         if (!isIconAv)
         {
            c1->setIcon (*getPredefinedIcon(category));
         }
         c1->setListItem (catI);
         c1->initListItem();
         categories.insert (c1->getCategoryName(), c1);
      }
   }
   f.close();
 }
 #endif // UNUSED
 void ZSafe::resume(int)
 {
-   qWarning ("Resume");
+   owarn << "Resume" << oendl;
   // hide the main window
   infoForm->hide();
   // open zsafe again
   m_password = "";
   selectedItem = NULL;
   // clear the password list
   QListViewItem *i;
   // step through all categories
   for (i = ListView->firstChild();
        i != NULL;
        i = i->nextSibling())
   {
      // step through all subitems
      QListViewItem *si;
      for (si = i->firstChild();
           si != NULL; )
      {
          QListViewItem *_si = si;
          si = si->nextSibling();
          i->takeItem(_si); // remove from view list
          if (_si) delete _si;
      }
@@ -1797,58 +1792,58 @@ void ZSafe::resume(int)
 bool ZSafe::openDocument(const char* _filename, const char* )
 {
     int retval;
     char* entry[FIELD_SIZE];
 // #ifndef WIN32
     int validationFlag = conf->readNumEntry(APP_KEY+"valzsafe", 1);
 // #else
     // int validationFlag = 1;
 // #endif
     int pwdOk = 0;
     int numberOfTries = 3;
     for (int i=0; i < numberOfTries; i++)
     {
        QFile f(_filename);
        if (f.exists())
        {
           // ask with a dialog for the password
       if (m_password.isEmpty())
          getDocPassword(tr("Enter Password"));
       if (m_password.isEmpty() && validationFlag == 0)
           {
-              qWarning ("Wrong password");
+              owarn << "Wrong password" << oendl;
              QMessageBox::critical( 0, tr("ZSafe"),
                  tr("Wrong password.\n\nZSafe will now exit.") );
              exitZs (1);
           }
       retval = loadInit(_filename, m_password);
       if (retval != PWERR_GOOD)
           {
-                qWarning ("Error loading Document");
+                owarn << "Error loading Document" << oendl;
        return false;
       }
        }
        else
        {
 #ifdef WIN32
           this->setCaption("Qt ZSafe");
 #else
           this->setCaption("ZSafe");
 #endif
           filename = "";
           return false;
        }
        // load the validation entry
        if (validationFlag == 0)
        {
            pwdOk = 1;
            break;
        }
    retval = loadEntry(entry);
        if (retval == 1 &&
@@ -2280,49 +2275,49 @@ bool ZSafe::saveDocument(const char* _filename,
        }
    if (saveFinalize() == PWERR_DATA) {
                owarn << "2: Error writing file, contents not saved" << oendl;
        return false;
    } else {
 #ifndef DESKTOP
                Global::statusMessage (tr("Password file saved."));
 #endif
                modified = false;
        return true;
    }
 }
 PasswordForm *newPwdDialog;
 bool newPwdDialogResult = false;
 void ZSafe::setPasswordDialogDone()
 {
   newPwdDialogResult = true;
   newPwdDialog->close();
 }
 void ZSafe::getDocPassword(QString title)
 {
-qWarning ("getDocPassword");
+    owarn << "getDocPassword" << oendl;
    // open the 'Password' dialog
    PasswordForm *dialog = new PasswordForm(this, title, TRUE);
    newPwdDialog = dialog;
    newPwdDialogResult = false;
    connect( dialog->PasswordField, SIGNAL( returnPressed() ),
             this, SLOT( setPasswordDialogDone() ) );
    // CS: !!!
    // int pos = filename.findRev ('/');
    QString ti = filename.right (filename.length() - filename.findRev ('/') - 1);
 #ifdef WIN32
    dialog->setCaption("Qt " + ti);
 #else
    dialog->setCaption(ti);
 #endif
    // dialog->setCaption(title);
    dialog->PasswordField->setFocus();
    DialogCode result = (DialogCode) dialog->exec();
 #ifdef DESKTOP
       result = Accepted;
 #endif
@@ -2459,49 +2454,49 @@ int ZSafe::saveFinalize(void)
     * over, leaving us 3 short, so we fill it in with 3's.
     *
     * If we come out even, we fill it with 8 8s
     *
     * um, except that in this instance we are using 4 shorts instead of 8 bytes.
     * so, half everything
     */
    for (count1 = bufferIndex; count1 < 4; count1++) {
        plaintext[count1] = (4 - bufferIndex);
    }
    krc2->rc2_encrypt (plaintext);
    for (count1 = 0; count1 < 4; count1++) {
        ciphertext[count1] = iv[count1] ^ plaintext[count1];
        if (putc ((unsigned char) (ciphertext[count1] >> 8), fd) == EOF) retval = PWERR_DATA;
        if (putc ((unsigned char) (ciphertext[count1] & 0xff), fd) == EOF) retval = PWERR_DATA;
    }
    fclose (fd);
    free(buffer);
    return retval;
 }
 void ZSafe::quitMe ()
 {
-    qWarning ("QUIT...");
+    owarn << "QUIT..." << oendl;
    if (modified)
    {
      switch( QMessageBox::information( this, tr("ZSafe"),
                                      tr("Do you want to save\nbefore exiting?"),
                                      tr("&Save"),
                                      tr("S&ave with\nnew\npassword"),
                                      tr("&Don't Save"),
                                      0      // Enter == button 0
                                      ) )
      { // Escape == button 2
      case 0: // Save clicked, Alt-S or Enter pressed.
        // save
        modified = false;
        saveDocument(filename, FALSE);
        exitZs (1);
        break;
      case 1: //
        // Save with new password
        modified = false;
        saveDocument(filename, TRUE);
        exitZs (1);
        break;
      case 2: // Don't Save clicked or Alt-D pressed
@@ -2663,49 +2658,49 @@ void ZSafe::addCategory()
        waitDialog.hide();
           }
 #ifndef WIN32
        dialog->show();
 #endif
 #ifndef DESKTOP
        // dialog->move (20, 100);
 #endif
        DialogCode result = (DialogCode) dialog->exec();
 #ifdef DESKTOP
       result = Accepted;
 #endif
        QString category;
        QString icon;
        QString fullIconPath;
        QPixmap *pix;
        if (result == Accepted)
        {
           modified = true;
           category = dialog->CategoryField->currentText();
           icon = dialog->IconField->currentText()+".png";
-           qWarning (category);
+           owarn << category << oendl;
           QListViewItem *li = new ShadedListItem( 1, ListView );
           Category *c1 = new Category();
           c1->setCategoryName(category);
           // if (!icon.isEmpty() && !icon.isNull())
           if (icon != "predefined.png")
           {
               // build the full path
               fullIconPath = iconPath + icon;
               pix = new QPixmap (fullIconPath);
               // pix->resize(14, 14);
               if (pix)
               {
                  // save the full pixmap name into the config file
 // #ifndef WIN32
                  conf->writeEntry(APP_KEY+category, icon);
 // #endif
                  saveConf();
                  QImage img = pix->convertToImage();
                  pix->convertFromImage(img.smoothScale(14,14));
                  c1->setIcon (*pix);
                  c1->setIconName(icon);
               }
@@ -3171,49 +3166,49 @@ void ZSafe::editCategory()
                     // save the full pixmap name into the config file
 // #ifndef WIN32
                     conf->writeEntry(APP_KEY+category, icon);
 // #endif
                     saveConf();
                     QImage img = pix->convertToImage();
                     pix->convertFromImage(img.smoothScale(14,14));
                     cat->setIconName (icon);
                     cat->setIcon (*pix);
                  }
              }
              else
              {
 // #ifndef WIN32
                 conf->removeEntry (category);
 // #endif
                 saveConf();
                 cat->setIcon (*getPredefinedIcon(category));
              }
              // change the category name of the selected category
              QListViewItem *catItem = cat->getListItem();
              if (catItem)
              {
-                 qWarning (category);
+                 owarn << category << oendl;
                 catItem->setText( 0, tr( category ) );
                 cat->setCategoryName (tr(category));
                 cat->initListItem();
                 categories.insert (category, cat);
              }
           }
           saveCategoryDialogFields(dialog);
        }
        else
        {
           // delete dialog;
           dialog->hide();
           return;
        }
    }
 }
 void ZSafe::cutItem()
 {
    if (!selectedItem)
       return;
    if (!isCategory(selectedItem))
@@ -3572,49 +3567,49 @@ void ZSafe::setExpandFlag()
   file->setItemChecked('o', expandTree);
 #ifndef DESKTOP
   conf->setGroup ("zsafePrefs");
 #endif
 // #ifndef WIN32
   conf->writeEntry (APP_KEY+"expandTree", expandTree);
 // #endif
   saveConf();
 }
 void ZSafe::paintEvent( QPaintEvent * )
 {
   if (raiseFlag)
   {
      raiseFlag = false;
      raiseTimer.start (1, true);
      if (infoForm->isVisible())
         infoForm->raise();
   }
 }
 void ZSafe::resizeEvent ( QResizeEvent * )
 {
-   // qWarning ("resizeEvent");
+   // owarn << "resizeEvent" << oendl;
 #ifndef DESKTOP
   DeskW = appl->desktop()->width();
   DeskH = appl->desktop()->height();
 #else
   DeskW = this->width();
   DeskH = this->height();
 #endif
   if (New)
      New->setGeometry   ( QRect( DeskW-84, 2, 20, 20 ) );
   if (Edit)
      Edit->setGeometry  ( QRect( DeskW-64, 2, 20, 20 ) );
   if (Delete)
      Delete->setGeometry( QRect( DeskW-44, 2, 20, 20 ) );
   if (Find)
      Find->setGeometry  ( QRect( DeskW-24, 2, 20, 20 ) );
 }
 void ZSafe::slotRaiseTimer()
 {
   if (infoForm->isVisible())
      infoForm->raise();
   raiseFlag = true;
 }
diff --git a/noncore/comm/keypebble/krfbdecoder.cpp b/noncore/comm/keypebble/krfbdecoder.cpp
index d61433f..837fcc5 100644
--- a/noncore/comm/keypebble/krfbdecoder.cpp
+++ b/noncore/comm/keypebble/krfbdecoder.cpp
@@ -4,51 +4,51 @@
 #include "krfbbuffer.h"
 /* OPIE */
 #include <opie2/odebug.h>
 using namespace Opie::Core;
 /* QT */
 #include <qpixmap.h>
 /* STD */
 #include <assert.h>
 //
 // Endian stuff
 //
 //#ifndef OPIE_NO_DEBUG
 const int endianTest = 1;
 //#endif
 #define Swap16IfLE(s) \
    (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s))
 #define Swap32IfLE(l) \
    (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \
-                             (((l) & 0x00ff0000) >> 8)  | \
+                 (((l) & 0x00ff0000) >> 8)  | \
-                             (((l) & 0x0000ff00) << 8)  | \
+                 (((l) & 0x0000ff00) << 8)  | \
-                             (((l) & 0x000000ff) << 24))  : (l))
+                 (((l) & 0x000000ff) << 24))  : (l))
 //
 // The lengths of the messages we need to wait for
 //
 const int ServerInitLength = 24;
 const int UpdateHeaderLength = 4;
 const int RectHeaderLength = 12;
 const int RectChunkSize = 4;
 const int CopyRectPosLength = 4;
 const int ServerCutLenLength = 7;
 //
 // Client -> Server Message Identifiers
 //
 static CARD8 SetPixelFormatId = 0;
 //static CARD8 FixColourMapEntriesId = 1; // Not used
 static CARD8 SetEncodingsId = 2;
 static CARD8 UpdateRequestId = 3;
 static CARD8 KeyEventId = 4;
 static CARD8 PointerEventId = 5;
 static CARD8 ClientCutTextId = 6;
 //
 // Server -> Client Message Identifiers
@@ -119,178 +119,174 @@ KRFBDecoder::KRFBDecoder( KRFBConnection *con )
  this->info = 0;
  this->format = 0;
  this->buttonMask = 0;
  currentState = Idle;
 }
 KRFBDecoder::~KRFBDecoder()
 {
  if ( info )
    delete info;
  if ( format )
    delete format;
 }
 void KRFBDecoder::start()
 {
  sendClientInit();
 }
 void KRFBDecoder::sendClientInit()
 {
  con->write( &( con->options()->shared ), 1 );
  // Wait for server init
-  owarn << "Waiting for server init" << oendl; 
+  owarn << "Waiting for server init" << oendl;
  static QString statusMsg = tr( "Waiting for server initialization..." );
  emit status( statusMsg );
  currentState = AwaitingServerInit;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerInit() ) );
  con->waitForData( ServerInitLength );
 }
 void KRFBDecoder::gotServerInit()
 {
-  owarn << "Got server init" << oendl; 
+  owarn << "Got server init" << oendl;
  disconnect( con, SIGNAL( gotEnoughData() ), this, SLOT( gotServerInit() ) );
  if ( info )
    delete info;
  info = new KRFBServerInfo;
  CHECK_PTR( info );
  con->read( &(info->width), 2 );
  info->width = Swap16IfLE( info->width );
  con->read( &info->height, 2 );
  info->height = Swap16IfLE( info->height );
  con->read( &(info->bpp), 1 );
  con->read( &(info->depth), 1 );
  con->read( &(info->bigEndian), 1 );
  con->read( &(info->trueColor), 1 );
  con->read( &(info->redMax), 2 );
  info->redMax = Swap16IfLE( info->redMax );
  con->read( &(info->greenMax), 2 );
  info->greenMax = Swap16IfLE( info->greenMax );
  con->read( &(info->blueMax), 2 );
  info->blueMax = Swap16IfLE( info->blueMax );
  con->read( &(info->redShift), 1 );
  con->read( &(info->greenShift), 1 );
  con->read( &(info->blueShift), 1 );
  con->read( info->padding, 3 );
  con->read( &(info->nameLength), 4 );
  info->nameLength = Swap32IfLE( info->nameLength );
-  owarn << "Width = " << info->width << ", Height = " << info->height << "" << oendl; 
+  owarn << "Width = " << info->width << ", Height = " << info->height << "" << oendl;
-  qWarning( "Bpp = %d, Depth = %d, Big = %d, True = %d",
+  owarn << "Bpp = " << info->bpp << ", Depth = " << info->depth << ", Big = " << info->bigEndian
-           info->bpp, info->depth, info->bigEndian, info->trueColor );
+        << ", True = " << info->trueColor << oendl;
-  qWarning( "RedMax = %d, GreenMax = %d, BlueMax = %d",
+  owarn << "RedMax = " << info->redMax << ", GreenMax = " << info->greenMax << ", BlueMax = " << info->blueMax << oendl;
-           info->redMax, info->greenMax, info->blueMax );
+  owarn << "RedShift = " << info->redShift << ", GreenShift = " << info->greenShift
-  qWarning( "RedShift = %d, GreenShift = %d, BlueShift = %d",
+        << ", BlueShift = " << info-> blueShift << oendl;
-           info->redShift, info->greenShift,info-> blueShift );
  buf->resize( info->width/con->options()->scaleFactor, info->height /con->options()->scaleFactor);
  // Wait for desktop name
-  owarn << "Waiting for desktop name" << oendl; 
+  owarn << "Waiting for desktop name" << oendl;
  static QString statusMsg = tr( "Waiting for desktop name..." );
  emit status( statusMsg );
  currentState = AwaitingDesktopName;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotDesktopName() ) );
  con->waitForData( info->nameLength );
 }
 void KRFBDecoder::gotDesktopName()
 {
  assert( info );
  assert( currentState == AwaitingDesktopName );
-  owarn << "Got desktop name" << oendl; 
+  owarn << "Got desktop name" << oendl;
  disconnect( con, SIGNAL( gotEnoughData() ),
-              this, SLOT( gotDesktopName() ) );
+          this, SLOT( gotDesktopName() ) );
  char *buf = new char[ info->nameLength + 1 ];
  CHECK_PTR( buf );
  con->read( buf, info->nameLength );
  buf[ info->nameLength ] = '\0';
  info->name = buf;
-  owarn << "Desktop: " << info->name.latin1() << "" << oendl; 
+  owarn << "Desktop: " << info->name.latin1() << "" << oendl;
  delete buf;
  // Get the format we'll really use and tell the server
  decidePixelFormat();
  sendPixelFormat();
  sendAllowedEncodings();
  currentState = Idle;
  QString msg;
  msg = tr( "Connected to %1" );
  msg = msg.arg( info->name );
  emit status( msg );
  sendUpdateRequest( false );
 }
 void KRFBDecoder::decidePixelFormat()
 {
  assert( info );
  if ( format )
    delete format;
  format = new KRFBPixelFormat;
  CHECK_PTR( format );
  // What depth do we want?
  //
  // We'll use the minimum of the remote and local depths, UNLESS an
  // eight bit session has been specifically requested by the user.
  int screenDepth = QPixmap::defaultDepth();
  int bestDepth = ( screenDepth > info->depth ) ? info->depth : screenDepth;
  int chosenDepth;
  if ( con->options()->colors256 )
    chosenDepth = 8;
  else
    chosenDepth = bestDepth;
-  qWarning( "Screen depth=%d, server depth=%d, best depth=%d, " \
+  owarn << "Screen depth=" << screenDepth << ", server depth=" << info->depth
-           "eight bit %d, chosenDepth=%d",
+        << ", best depth=" << bestDepth << "eight bit " << con->options()->colors256
-           screenDepth,
+        << ", chosenDepth=" << chosenDepth << oendl;
-           info->depth,
-           bestDepth,
-           con->options()->colors256, chosenDepth );
  format->depth = chosenDepth;
  // If we're using the servers native depth
  if ( chosenDepth == info->depth ) {
    // Use the servers native format
    format->bpp = info->bpp;
    //    format->bigEndian = info->bigEndian;
    format->bigEndian = true;
    format->trueColor = info->trueColor;
    format->redMax = info->redMax;
    format->greenMax = info->greenMax;
    format->blueMax = info->blueMax;
    format->redShift = info->redShift;
    format->greenShift = info->greenShift;
    format->blueShift = info->blueShift;
  }
  else {
    if ( chosenDepth == 8 ) {
      format->bpp = 8;
      format->bigEndian = true;
      format->trueColor = true;
      format->redMax = 7;
      format->greenMax = 7;
@@ -355,436 +351,436 @@ void KRFBDecoder::sendUpdateRequest( bool incremental )
    return;
  con->write( &UpdateRequestId, 1 );
  con->write( &incremental, 1 );
  static CARD16 x = 0, y = 0;
  static CARD16 w = Swap16IfLE( info->width );
  static CARD16 h = Swap16IfLE( info->height );
  con->write( &x, 2 );
  con->write( &y, 2 );
  con->write( &w, 2 );
  con->write( &h, 2 );
  // Now wait for the update
  currentState = AwaitingUpdate;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) );
  con->waitForData( UpdateHeaderLength );
 }
 void KRFBDecoder::gotUpdateHeader()
 {
  assert( currentState == AwaitingUpdate );
-  //  owarn << "Got update header" << oendl; 
+  //  owarn << "Got update header" << oendl;
  disconnect( con, SIGNAL( gotEnoughData() ),
-              this, SLOT( gotUpdateHeader() ) );
+          this, SLOT( gotUpdateHeader() ) );
  CARD8 msgType;
  con->read( &msgType, 1 );
  if ( msgType != UpdateId ) {
    // We might have a bell or server cut
    if ( msgType == ServerCutId ) {
      oldState = currentState;
      gotServerCut();
    }
    else if ( msgType == BellId ) {
      oldState = currentState;
      gotBell();
    }
    else {
      int msg = msgType;
      QString protocolError = tr( "Protocol Error: Message Id %1 was "
                                    "found when expecting an update "
                                    "message." ).arg( msg );
      currentState = Error;
      emit error( protocolError );
    }
    return;
  }
  CARD8 padding;
  con->read( &padding, 1 );
  con->read( &noRects, 2 );
  noRects = Swap16IfLE( noRects );
-  //  owarn << "Expecting " << noRects << " rects" << oendl; 
+  //  owarn << "Expecting " << noRects << " rects" << oendl;
  // Now wait for the data
  currentState = AwaitingRectHeader;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
  con->waitForData( RectHeaderLength );
 }
 void KRFBDecoder::gotRectHeader()
 {
  assert( currentState == AwaitingRectHeader );
-  //  owarn << "Got rect header" << oendl; 
+  //  owarn << "Got rect header" << oendl;
  disconnect( con, SIGNAL( gotEnoughData() ),
-              this, SLOT( gotRectHeader() ) );
+          this, SLOT( gotRectHeader() ) );
  con->read( &x, 2 );
  x = Swap16IfLE( x );
  con->read( &y, 2 );
  y = Swap16IfLE( y );
  con->read( &w, 2 );
  w = Swap16IfLE( w );
  con->read( &h, 2 );
  h = Swap16IfLE( h );
  con->read( &encoding, 4 );
  //  CARD32 encodingLocal = Swap32IfLE( encoding );
-  //  qWarning( "Rect: x=%d, y= %d, w=%d, h=%d, encoding=%ld",
+  //  owarn << "Rect: x=" << x << ", y= " << y << ", w=" << w << ", h=" << h
-          //   x, y, w, h, encodingLocal );
+  //        << ", encoding= " << encodingLocal << oendl;
  //
  // Each encoding needs to be handled differently. Some require
  // waiting for more data, but others like a copyrect do not.
  // Our constants have already been byte swapped, so we use
  // the remote value as is.
  //
  if ( encoding == RawEncoding ) {
-      //    owarn << "Raw encoding" << oendl; 
+      //    owarn << "Raw encoding" << oendl;
    handleRawRect();
  }
  else if ( encoding == CopyRectEncoding ) {
-//    owarn << "CopyRect encoding" << oendl; 
+//    owarn << "CopyRect encoding" << oendl;
    handleCopyRect();
  }
  else if ( encoding == RreEncoding ) {
-    owarn << "RRE encoding" << oendl; 
+    owarn << "RRE encoding" << oendl;
    handleRRERect();
  }
  else if ( encoding == CorreEncoding ) {
-    owarn << "CoRRE encoding" << oendl; 
+    owarn << "CoRRE encoding" << oendl;
    handleCoRRERect();
  }
  else if ( encoding == HexTileEncoding ) {
-    owarn << "HexTile encoding" << oendl; 
+    owarn << "HexTile encoding" << oendl;
    handleHexTileRect();
  }
  else {
    int msg = Swap32IfLE( encoding );
    QString protocolError = tr( "Protocol Error: An unknown encoding was "
-                                  "used by the server %1" ).arg( msg );
+                  "used by the server %1" ).arg( msg );
    currentState = Error;
-    owarn << "Unknown encoding, " << msg << "" << oendl; 
+    owarn << "Unknown encoding, " << msg << "" << oendl;
    emit error( protocolError );
    return;
  }
 }
 //
 // Raw Encoding
 //
 void KRFBDecoder::handleRawRect()
 {
  // We need something a bit cleverer here to handle large
  // rectanges nicely. The chunking should be based on the
  // overall size (but has to be in complete lines).
-    //  owarn << "Handling a raw rect chunk" << oendl; 
+    //  owarn << "Handling a raw rect chunk" << oendl;
    //  CARD32 lineCount = w * format->bpp / 8;
  if ( h > RectChunkSize ) {
    //    if ( con->sock->size() / lineCount ) {
    //      getRawRectChunk( con->sock->size() / lineCount );
    //    }
    //    else {
      getRawRectChunk( RectChunkSize );
      //   }
  }
  else {
    getRawRectChunk( h );
  }
 }
 void KRFBDecoder::getRawRectChunk( int lines )
 {
  this->lines = lines;
  CARD32 count = lines * w * format->bpp / 8;
  // Wait for server init
-  //  owarn << "Waiting for raw rect chunk, " << count << "" << oendl; 
+  //  owarn << "Waiting for raw rect chunk, " << count << "" << oendl;
  currentState = AwaitingRawRectChunk;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRawRectChunk() ) );
  con->waitForData( count );
 }
 void KRFBDecoder::gotRawRectChunk()
 {
  assert( currentState == AwaitingRawRectChunk );
  disconnect( con, SIGNAL( gotEnoughData() ),
              this, SLOT( gotRawRectChunk() ) );
-  //  owarn << "Got raw rect chunk" << oendl; 
+  //  owarn << "Got raw rect chunk" << oendl;
  //
  // Read the rect data and copy it to the buffer.
  //
  // TODO: Replace this!
  int count = lines * w * format->bpp / 8;
  char *hack = new char[ count ];
  con->read( hack, count );
  buf->drawRawRectChunk( hack, x, y, w, lines );
  delete hack;
  // /TODO:
  h = h - lines;
  y = y + lines;
  if ( h > 0 ) {
    handleRawRect();
  }
  else {
    noRects--;
-    //    owarn << "There are " << noRects << " rects left" << oendl; 
+    //    owarn << "There are " << noRects << " rects left" << oendl;
    if ( noRects ) {
      currentState = AwaitingRectHeader;
      connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
      con->waitForData( RectHeaderLength );
    }
    else {
      // we are now ready for the next update - no need to wait for the timer
      currentState = Idle;
      sendUpdateRequest (1);
    }
  }
 }
 //
 // Copy Rectangle Encoding
 //
 void KRFBDecoder::handleCopyRect()
 {
  currentState = AwaitingCopyRectPos;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotCopyRectPos() ) );
  con->waitForData( CopyRectPosLength );
 }
 void KRFBDecoder::gotCopyRectPos()
 {
  disconnect( con, SIGNAL( gotEnoughData() ),
              this, SLOT( gotCopyRectPos() ) );
  CARD16 srcX;
  CARD16 srcY;
  con->read( &srcX, 2 );
  con->read( &srcY, 2 );
  srcX = Swap16IfLE( srcX );
  srcY = Swap16IfLE( srcY );
  buf->copyRect( srcX, srcY, x, y, w, h );
  noRects--;
-  //    owarn << "There are " << noRects << " rects left" << oendl; 
+  //    owarn << "There are " << noRects << " rects left" << oendl;
  if ( noRects ) {
    currentState = AwaitingRectHeader;
    connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
    con->waitForData( RectHeaderLength );
  }
  else
    currentState = Idle;
 }
 void KRFBDecoder::handleRRERect()
 {
-  owarn << "RRE not implemented" << oendl; 
+  owarn << "RRE not implemented" << oendl;
 }
 void KRFBDecoder::handleCoRRERect()
 {
-  owarn << "CoRRE not implemented" << oendl; 
+  owarn << "CoRRE not implemented" << oendl;
 }
 void KRFBDecoder::handleHexTileRect()
 {
-  owarn << "HexTile not implemented" << oendl; 
+  owarn << "HexTile not implemented" << oendl;
 }
 void KRFBDecoder::sendMouseEvent( QMouseEvent *e )
 {
  // Deal with the buttons
  if ( e->type() != QEvent::MouseMove ) {
    buttonMask = 0;
    if ( e->type() == QEvent::MouseButtonPress ) {
      if ( e->button() & LeftButton )
        buttonMask |= 0x01;
      if ( e->button() & MidButton )
        buttonMask |= 0x04;
      if ( e->button() & RightButton )
        buttonMask |= 0x02;
    }
    else if ( e->type() == QEvent::MouseButtonRelease ) {
      if ( e->button() & LeftButton )
        buttonMask &= 0x06;
      if ( e->button() & MidButton )
        buttonMask |= 0x03;
      if ( e->button() & RightButton )
        buttonMask |= 0x05;
    }
  }
-        // HACK: Scaling
+    // HACK: Scaling
  CARD16 x = Swap16IfLE( e->x() * con->options()->scaleFactor );
-          CARD16 y = Swap16IfLE( e->y() *con->options()->scaleFactor );
+  CARD16 y = Swap16IfLE( e->y() *   con->options()->scaleFactor );
  con->write( &PointerEventId, 1 );
  con->write( &buttonMask, 1 );
  con->write( &x, 2 );
  con->write( &y, 2 );
 }
 void KRFBDecoder::sendCutEvent( const QString &unicode )
 {
  //
  // Warning: There is a bug in the RFB protocol because there is no way to find
  // out the codepage in use on the remote machine. This could be fixed by requiring
  // the remote server to use utf8 etc. but for now we have to assume they're the
  // same. I've reported this problem to the ORL guys, but they apparantly have no
  // immediate plans to fix the issue. :-( (rich)
  //
  CARD8 padding[3];
  QCString text = unicode.local8Bit();
  CARD32 length = text.length();
  length = Swap32IfLE( length );
  con->write( &ClientCutTextId, 1 );
  con->write( &padding, 3 );
  con->write( &length, 4 );
  con->write( text.data(), length );
 }
 void KRFBDecoder::gotServerCut()
 {
-  owarn << "Got server cut" << oendl; 
+  owarn << "Got server cut" << oendl;
  currentState = AwaitingServerCutLength;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutLength() ) );
  con->waitForData( ServerCutLenLength );
 }
 void KRFBDecoder::gotServerCutLength()
 {
  assert( currentState = AwaitingServerCutLength );
  disconnect( con, SIGNAL( gotEnoughData() ),
              this, SLOT( gotServerCutLength() ) );
  CARD8 padding[3];
  con->read( padding, 3 );
  con->read( &serverCutTextLen, 4 );
  serverCutTextLen = Swap32IfLE( serverCutTextLen );
  currentState = AwaitingServerCutText;
  connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutText() ) );
  con->waitForData( serverCutTextLen );
 }
 void KRFBDecoder::gotServerCutText()
 {
  assert( currentState = AwaitingServerCutText );
  disconnect( con, SIGNAL( gotEnoughData() ),
              this, SLOT( gotServerCutText() ) );
  //
  // Warning: There is a bug in the RFB protocol because there is no way to find
  // out the codepage in use on the remote machine. This could be fixed by requiring
  // the remote server to use utf8 etc. but for now we have to assume they're the
  // same. I've reported this problem to the ORL guys, but they apparantly have no
  // immediate plans to fix the issue. :-( (rich)
  //
  char *cutbuf = new char[ serverCutTextLen + 1 ];
  CHECK_PTR( cutbuf );
  con->read( cutbuf, serverCutTextLen );
  cutbuf[ serverCutTextLen ] = '\0';
  /* For some reason QApplication::clipboard()->setText() segfaults when called
   * from within keypebble's mass of signals and slots
-  owarn << "Server cut: " << cutbuf << "" << oendl; 
+  owarn << "Server cut: " << cutbuf << "" << oendl;
  QString cutText( cutbuf ); // DANGER!!
  qApp->clipboard()->setText( cutText );
  */
  delete cutbuf;
  // Now wait for the update (again)
  if ( oldState == AwaitingUpdate ) {
    currentState = AwaitingUpdate;
    connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) );
    con->waitForData( UpdateHeaderLength );
  }
  else if ( oldState == Idle ) {
    currentState = Idle;
  }
  else {
-    owarn << "Async handled in weird state" << oendl; 
+    owarn << "Async handled in weird state" << oendl;
    currentState = oldState;
  };
 }
 void KRFBDecoder::gotBell()
 {
-  owarn << "Got server bell" << oendl; 
+  owarn << "Got server bell" << oendl;
  buf->soundBell();
  // Now wait for the update (again)
  if ( oldState == AwaitingUpdate ) {
    currentState = AwaitingUpdate;
    connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) );
    con->waitForData( UpdateHeaderLength );
  }
  else if ( oldState == Idle ) {
    currentState = Idle;
  }
  else {
-    owarn << "Async handled in weird state" << oendl; 
+    owarn << "Async handled in weird state" << oendl;
    currentState = oldState;
  };
 }
 void KRFBDecoder::sendKeyPressEvent( QKeyEvent *event )
 {
  int key;
  key = toKeySym( event );
  if ( key ) {
    key = Swap32IfLE( key );
    CARD8 mask = true;
    CARD16 padding = 0;
    con->write( &KeyEventId, 1 );
    con->write( &mask, 1 );
    con->write( &padding, 2 );
    con->write( &key, 4 );
  }
 }
 void KRFBDecoder::sendKeyReleaseEvent( QKeyEvent *event )
 {
  int key;
@@ -798,38 +794,38 @@ void KRFBDecoder::sendKeyReleaseEvent( QKeyEvent *event )
    con->write( &KeyEventId, 1 );
    con->write( &mask, 1 );
    con->write( &padding, 2 );
    con->write( &key, 4 );
  }
 }
 //
 // The RFB protocol spec says 'For most ordinary keys, the 'keysym'
 // is the same as the corresponding ASCII value.', but doesn't
 // elaborate what the most ordinary keys are.  The spec also lists
 // a set (possibly subset, it's unspecified) of mappings for
 // "other common keys" (backspace, tab, return, escape, etc).
 //
 int KRFBDecoder::toKeySym( QKeyEvent *k )
 {
    //
    // Try and map these "other common keys" first.
    //
    if ((k->key() >= Qt::Key_Escape) && (k->key() <= Qt::Key_F12)) {
-        for(int i = 0; keyMap[i].keycode != 0; i++) {
+    for(int i = 0; keyMap[i].keycode != 0; i++) {
-            if (k->key() == keyMap[i].keycode) {
+        if (k->key() == keyMap[i].keycode) {
-                return keyMap[i].keysym;
+        return keyMap[i].keysym;
-            }
+        }
-        }
+    }
    }
    //
    // If these keys aren't matched, return the ascii code and let the
    // server figure it out.  We don't return k->key(), as the data in
    // key differs between input methods, and we don't want special cases.
    //
    return k->ascii();
 }
diff --git a/noncore/graphics/opie-eye/gui/iconview.cpp b/noncore/graphics/opie-eye/gui/iconview.cpp
index 6c5f5ea..211314b 100644
--- a/noncore/graphics/opie-eye/gui/iconview.cpp
+++ b/noncore/graphics/opie-eye/gui/iconview.cpp
@@ -89,51 +89,51 @@ namespace {
    IconViewItem::IconViewItem( QIconView* view,const QString& path,
                                const QString& name, bool isDir )
        : QIconViewItem( view, name ), m_path( path ), m_isDir( isDir ),
          m_noInfo( false ),m_textOnly(false),m_Pixset(false)
    {
        if ( isDir && !_dirPix )
            _dirPix = new QPixmap( Resource::loadPixmap("advancedfm/FileBrowser"));
        else if ( !isDir && !_unkPix )
            _unkPix = new QPixmap( Resource::loadPixmap( "UnknownDocument" ) );
    }
    inline void IconViewItem::setPixmap( const QPixmap & icon, bool recalc, bool redraw)
    {
        m_Pixset = true;
        calcRect(text());
    }
    inline void IconViewItem::setPixmap( const QPixmap & icon)
    {
        m_Pixset = true;
        calcRect(text());
    }
    inline QPixmap* IconViewItem::pixmap()const {
-//      qWarning(  "Name is " + m_path.right( 15 ) + " rect is %d %d %d %d | %d %d",
+//      owarn << "Name is " << m_path.right( 15 ) << " rect is " << rect().x() << " " << rect().y()
-//                 rect().x(),rect().y(),rect().width(),rect().height(),
+//            << " " << rect().width() << " " << rect().height() << " | " << iconView()->contentsX()
-//                 iconView()->contentsX(), iconView()->contentsY());
+//            << " " << iconView()->contentsY() << oendl;
        if (textOnly()&&!m_isDir) {
            if (!_emptyPix) _emptyPix = new QPixmap(0,0,1);
            return _emptyPix;
        }
        if ( m_isDir )
            return _dirPix;
        else{
            if (!m_noInfo && !g_stringInf.contains( m_path ) ) {
                currentView()->dirLister()->imageInfo( m_path );
                g_stringInf.insert( m_path, const_cast<IconViewItem*>(this));
            }
            m_pix = PPixmapCache::self()->cachedImage( m_path, 64, 64 );
            if (!m_pix && !g_stringPix.contains( m_path )) {
                currentView()->dirLister()->thumbNail( m_path, 64, 64 );
                g_stringPix.insert( m_path, const_cast<IconViewItem*>(this));
            }
            return m_pix ? m_pix : _unkPix;
        }
    }
    inline void IconViewItem::setText( const QString& str ) {
        QString text = QIconViewItem::text()+"\n"+str;
        m_noInfo = true;
diff --git a/noncore/graphics/opie-eye/gui/viewmodebutton.cpp b/noncore/graphics/opie-eye/gui/viewmodebutton.cpp
index 36e5dcf..aa15d31 100644
--- a/noncore/graphics/opie-eye/gui/viewmodebutton.cpp
+++ b/noncore/graphics/opie-eye/gui/viewmodebutton.cpp
@@ -1,45 +1,48 @@
 #include "viewmodebutton.h"
+/* OPIE */
 #include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #include <qtoolbar.h>
 #include <qpopupmenu.h>
 ViewModeButton::ViewModeButton( QToolBar* bar,int def )
    : QToolButton( bar )
 {
    slotChange( def );
    QPopupMenu *pop= new QPopupMenu( this );
    pop->setCheckable( true );
    pop->insertItem( tr("Thumbnail and Imageinfo"), 1 );
    pop->insertItem( tr("Thumbnail and Name" ), 2 );
    pop->insertItem( tr("Name Only" ), 3 );
    connect(pop, SIGNAL(activated(int)),
            this, SIGNAL(changeMode(int)) );
    connect(pop, SIGNAL(activated(int)),
            this, SLOT(slotChange(int)) );
    setPopup( pop );
 }
 ViewModeButton::~ViewModeButton() {
 }
 void ViewModeButton::slotChange( int i ) {
    QString name;
    switch( i ) {
    case 1:
        name = "opie-eye/opie-eye-thumb";
        break;
    case 2:
        name = "opie-eye/opie-eye-thumbonly";
        break;
    case 3:
        name = "opie-eye/opie-eye-textview";
        break;
    }
-    qWarning("foo %d" +name, i );
+    owarn << "foo " << name << oendl;
    setIconSet( Resource::loadIconSet( name ) );
 }
diff --git a/noncore/net/opietooth/lib/device.cc b/noncore/net/opietooth/lib/device.cc
index 04c50d9..f81066e 100644
--- a/noncore/net/opietooth/lib/device.cc
+++ b/noncore/net/opietooth/lib/device.cc
@@ -1,152 +1,157 @@
-#include <signal.h>
+#include "device.h"
+/* OPIE */
 #include <opie2/oprocess.h>
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* STD */
+#include <signal.h>
-#include "device.h"
 using namespace OpieTooth;
 using Opie::Core::OProcess;
 namespace {
  int parsePid( const QCString& par ){
    int id=0;
    QString string( par );
    QStringList list =  QStringList::split( '\n', string );
    for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ){
-    qWarning("parsePID: %s", (*it).latin1() );
+    owarn << "parsePID: " << (*it).latin1() << oendl;
      if( !(*it).startsWith("CSR") ){
-        id = (*it).toInt();
+    id = (*it).toInt();
-        break;
+    break;
      }
    }
    return id;
  }
 }
 Device::Device(const QString &device, const QString &mode, const QString &speed )
  : QObject(0, "device") {
-  qWarning("OpieTooth::Device create" );
+  owarn << "OpieTooth::Device create" << oendl;
  m_hci = 0;
  m_process = 0;
  m_attached = false;
  m_device = device;
  m_mode = mode;
  m_speed = speed;
  attach();
 }
 Device::~Device(){
  detach();
 }
 void Device::attach(){
-  qWarning("attaching %s %s %s", m_device.latin1(), m_mode.latin1(), m_speed.latin1() );
+  owarn << "attaching " << m_device.latin1() << " " << m_mode.latin1() << " " << m_speed.latin1() << oendl;
  if(m_process == 0 ){
    m_output.resize(0);
-    qWarning("new process to create" );
+    owarn << "new process to create" << oendl;
    m_process = new OProcess();
    *m_process << "hciattach";
    *m_process << "-p";
    *m_process << m_device << m_mode << m_speed;
    connect(m_process, SIGNAL( processExited(Opie::Core::OProcess*) ),
            this, SLOT( slotExited(Opie::Core::OProcess* ) ) );
    connect(m_process, SIGNAL( receivedStdout(Opie::Core::OProcess*, char*, int) ),
            this, SLOT(slotStdOut(Opie::Core::OProcess*,char*,int ) ) );
    connect(m_process, SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ),
            this, SLOT(slotStdErr(Opie::Core::OProcess*,char*,int) ) );
    if(!m_process->start(OProcess::NotifyOnExit, OProcess::AllOutput ) ){
-      qWarning("Could not start" );
+      owarn << "Could not start" << oendl;
      delete m_process;
      m_process = 0;
    }
  };
 }
 void Device::detach(){
  delete m_hci;
  delete m_process;
  // kill the pid we got
  if(m_attached ){
    //kill the pid
-    qWarning( "killing" );
+    warn << "killing" << oendl;
    kill(pid, 9);
  }
-  qWarning("detached" );
+  owarn << "detached" << oendl;
 }
 bool Device::isLoaded()const{
  return m_attached;
 }
 QString Device::devName()const {
  return QString::fromLatin1("hci0");
 };
 void Device::slotExited( OProcess* proc)
 {
-  qWarning("prcess exited" );
+  owarn << "prcess exited" << oendl;
  if(proc== m_process ){
-    qWarning("proc == m_process" );
+    owarn << "proc == m_process" << oendl;
    if( m_process->normalExit() ){ // normal exit
-      qWarning("normalExit" );
+      owarn << "normalExit" << oendl;
      int ret = m_process->exitStatus();
      if( ret == 0 ){ // attached
-        qWarning("attached" );
+    owarn << "attached" << oendl;
-        qWarning("Output: %s", m_output.data() );
+    owarn << "Output: " << m_output.data() << oendl;
-        pid = parsePid( m_output );
+    pid = parsePid( m_output );
-        qWarning("Pid = %d", pid );
+    owarn << "Pid = " << pid << oendl;
-        // now hciconfig hci0 up ( determine hciX FIXME)
+    // now hciconfig hci0 up ( determine hciX FIXME)
-        // and call hciconfig hci0 up
+    // and call hciconfig hci0 up
-        // FIXME hardcoded to hci0 now :(
+    // FIXME hardcoded to hci0 now :(
-        m_hci = new OProcess( );
+    m_hci = new OProcess( );
-        *m_hci << "hciconfig";
+    *m_hci << "hciconfig";
-        *m_hci << "hci0 up";
+    *m_hci << "hci0 up";
-        connect(m_hci, SIGNAL( processExited(Opie::Core::OProcess*) ),
+    connect(m_hci, SIGNAL( processExited(Opie::Core::OProcess*) ),
                this, SLOT( slotExited(Opie::Core::OProcess* ) ) );
-        if(!m_hci->start() ){
+    if(!m_hci->start() ){
-          qWarning("could not start" );
+      owarn << "could not start" << oendl;
-          m_attached = false;
+      m_attached = false;
-          emit device("hci0", false );
+      emit device("hci0", false );
-        }
+    }
      }else{
-        qWarning("crass" );
+        owarn << "crass" << oendl;
-        m_attached = false;
+    m_attached = false;
-        emit device("hci0", false );
+    emit device("hci0", false );
      }
    }
    delete m_process;
    m_process = 0;
  }else if(proc== m_hci ){
-    qWarning("M HCI exited" );
+    owarn << "M HCI exited" << oendl;
    if( m_hci->normalExit() ){
-      qWarning("normal exit" );
+      owarn << "normal exit" << oendl;
      int ret = m_hci->exitStatus();
      if( ret == 0 ){
-        qWarning("attached really really attached" );
+    owarn << "attached really really attached" << oendl;
-        m_attached = true;
+    m_attached = true;
-        emit device("hci0", true );
+    emit device("hci0", true );
      }else{
-        qWarning( "failed" );
+    owarn << "failed" << oendl;
-        emit device("hci0", false );
+    emit device("hci0", false );
-        m_attached = false;
+    m_attached = false;
      }
    }// normal exit
    delete m_hci;
    m_hci = 0;
  }
 }
 void Device::slotStdOut(OProcess* proc, char* chars, int len)
 {
-  qWarning("std out" );
+  owarn << "std out" << oendl;
  if( len <1 ){
-    qWarning( "len < 1 " );
+    owarn << "len < 1 " << oendl;
    return;
  }
  if(proc == m_process ){
    QCString string( chars, len+1 ); // \0 == +1
-    qWarning("output: %s", string.data() );
+    owarn << "output: " << string.data() << oendl;
    m_output.append( string.data() );
  }
 }
 void Device::slotStdErr(OProcess* proc, char* chars, int len)
 {
-  qWarning("std err" );
+  owarn << "std err" << oendl;
  slotStdOut( proc, chars, len );
 }
diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc
index 18e1df9..76d9127 100644
--- a/noncore/net/opietooth/lib/manager.cc
+++ b/noncore/net/opietooth/lib/manager.cc
@@ -1,316 +1,317 @@
-#include <opie2/oprocess.h>
 #include "parser.h"
 #include "manager.h"
+#include <opie2/oprocess.h>
+#include <opie2/odebug.h>
+using namespace Opie::Core;
 using namespace OpieTooth;
 using Opie::Core::OProcess;
 Manager::Manager( const QString& dev )
  : QObject()
 {
-    qWarning("created");
+    owarn << "created" << oendl;
    m_device = dev;
    m_hcitool = 0;
    m_sdp = 0;
 }
 Manager::Manager( Device* /*dev*/ )
  : QObject()
 {
    m_hcitool = 0;
    m_sdp = 0;
 }
 Manager::Manager()
  : QObject()
 {
    m_hcitool = 0;
    m_sdp = 0;
 }
 Manager::~Manager(){
    delete m_hcitool;
    delete m_sdp;
 }
 void Manager::setDevice( const QString& dev ){
    m_device = dev;
 }
 void Manager::setDevice( Device* /*dev*/ ){
 }
 void Manager::isAvailable( const QString& device ){
    OProcess* l2ping = new OProcess();
    l2ping->setName( device.latin1() );
    *l2ping << "l2ping" << "-c1" << device;
    connect(l2ping, SIGNAL(processExited(Opie::Core::OProcess* ) ),
            this, SLOT(slotProcessExited(Opie::Core::OProcess*) ) );
    if (!l2ping->start() ) {
        emit available( device,  false );
        delete l2ping;
    }
 }
 void Manager::isAvailable( Device* /*dev*/ ){
 }
 void Manager::searchDevices( const QString& device ){
-    qWarning("search devices");
+    owarn << "search devices" << oendl;
    OProcess* hcitool = new OProcess();
    hcitool->setName( device.isEmpty() ? "hci0" : device.latin1() );
    *hcitool << "hcitool" << "scan";
    connect( hcitool, SIGNAL(processExited(Opie::Core::OProcess*) ) ,
             this, SLOT(slotHCIExited(Opie::Core::OProcess* ) ) );
    connect( hcitool, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int ) ),
             this, SLOT(slotHCIOut(Opie::Core::OProcess*, char*, int ) ) );
    if (!hcitool->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
-        qWarning("could not start");
+        owarn << "could not start" << oendl;
        RemoteDevice::ValueList list;
        emit foundDevices( device, list );
        delete hcitool;
    }
 }
 void Manager::searchDevices(Device* /*d*/ ){
 }
 void Manager::addService(const QString& name ){
    OProcess proc;
    proc << "sdptool" << "add" << name;
    bool bo = true;
    if (!proc.start(OProcess::DontCare ) )
        bo = false;
    emit addedService( name,  bo );
 }
 void Manager::addServices(const QStringList& list){
    QStringList::ConstIterator it;
    for (it = list.begin(); it != list.end(); ++it )
        addService( (*it) );
 }
 void Manager::removeService( const QString& name ){
    OProcess prc;
    prc << "sdptool" << "del" << name;
    bool bo = true;
    if (!prc.start(OProcess::DontCare ) )
        bo = false;
    emit removedService( name,  bo );
 }
 void Manager::removeServices( const QStringList& list){
    QStringList::ConstIterator it;
    for (it = list.begin(); it != list.end(); ++it )
        removeService( (*it) );
 }
 void Manager::searchServices( const QString& remDevice ){
    OProcess *m_sdp =new OProcess();
    *m_sdp << "sdptool" << "browse" << remDevice;
    m_sdp->setName( remDevice.latin1() );
-    qWarning("search Services for %s", remDevice.latin1() );
+    owarn << "search Services for " << remDevice.latin1() << oendl;
    connect(m_sdp, SIGNAL(processExited(Opie::Core::OProcess*) ),
            this, SLOT(slotSDPExited(Opie::Core::OProcess* ) ) );
    connect(m_sdp, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*,  int ) ),
            this, SLOT(slotSDPOut(Opie::Core::OProcess*, char*, int) ) );
    if (!m_sdp->start(OProcess::NotifyOnExit,  OProcess::AllOutput) ) {
-        qWarning("could not start sdptool" );
+        owarn << "could not start sdptool" << oendl;
        delete m_sdp;
        Services::ValueList list;
        emit foundServices( remDevice, list );
    }
 }
 void Manager::searchServices( const RemoteDevice& dev){
    searchServices( dev.mac() );
 }
 QString Manager::toDevice( const QString& /*mac*/ ){
    return QString::null;
 }
 QString Manager::toMac( const QString &/*device*/ ){
    return QString::null;
 }
 void Manager::slotProcessExited(OProcess* proc ) {
    bool conn= false;
    if (proc->normalExit() && proc->exitStatus() == 0 )
        conn = true;
    QString name = QString::fromLatin1(proc->name() );
    emit available( name, conn );
    delete proc;
 }
 void Manager::slotSDPOut(OProcess* proc, char* ch, int len)
 {
    QCString str(ch,  len+1 );
-    qWarning("SDP:%s", str.data() );
+    owarn << "SDP:" << str.data() << oendl;
    QMap<QString, QString>::Iterator it;
    it = m_out.find(proc->name() );
    QString string;
    if ( it != m_out.end() ) {
        string = it.data();
    }
    string.append( str );
    m_out.replace( proc->name(), string );
 }
 void Manager::slotSDPExited( OProcess* proc)
 {
-    qWarning("proc name %s", proc->name() );
+    owarn << "proc name " << proc->name() << oendl;
    Services::ValueList  list;
    if (proc->normalExit()  ) {
        QMap<QString, QString>::Iterator it = m_out.find( proc->name() );
        if ( it != m_out.end() ) {
-            qWarning("found process" );
+        owarn << "found process" << oendl;
            list = parseSDPOutput( it.data() );
            m_out.remove( it );
        }
    }
    emit foundServices( proc->name(), list );
    delete proc;
 }
 Services::ValueList Manager::parseSDPOutput( const QString& out ) {
    Services::ValueList list;
-    qWarning("parsing output" );
+    owarn << "parsing output" << oendl;
    Parser parser( out );
    list = parser.services();
    return list;
 }
 void Manager::slotHCIExited(OProcess* proc ) {
-    qWarning("process exited");
+    owarn << "process exited" << oendl;
    RemoteDevice::ValueList list;
    if (proc->normalExit() ) {
-        qWarning("normalExit %s",  proc->name() );
+        owarn << "normalExit " << proc->name() << oendl;
        QMap<QString, QString>::Iterator it = m_devices.find(proc->name() );
        if (it != m_devices.end() ) {
-            qWarning("!= end ;)");
+            owarn << "!= end ;)" << oendl;
            list = parseHCIOutput( it.data() );
            m_devices.remove( it );
        }
    }
    emit foundDevices( proc->name(), list );
    delete proc;
 }
 void Manager::slotHCIOut(OProcess* proc,  char* ch,  int len) {
    QCString str( ch, len+1 );
-    qWarning("hci: %s",  str.data() );
+    owarn << "hci: " << str.data() oendl;
    QMap<QString, QString>::Iterator it;
    it = m_devices.find( proc->name() );
-    qWarning("proc->name %s", proc->name() );
+    owarn << "proc->name " << proc->name() << oendl;
    QString string;
    if (it != m_devices.end() ) {
-        qWarning("slotHCIOut ");
+        owarn << "slotHCIOut " << oendl;
        string = it.data();
    }
    string.append( str );
    m_devices.replace( proc->name(),  string );
 }
 RemoteDevice::ValueList Manager::parseHCIOutput(const QString& output ) {
-    qWarning("parseHCI %s",  output.latin1() );
+    owarn << "parseHCI " << output.latin1() << oendl;
    RemoteDevice::ValueList list;
    QStringList strList = QStringList::split('\n',  output );
    QStringList::Iterator it;
    QString str;
    for ( it = strList.begin(); it != strList.end(); ++it ) {
        str = (*it).stripWhiteSpace();
-        qWarning("OpieTooth %s", str.latin1() );
+        owarn << "OpieTooth " << str.latin1() << oendl;
        int pos = str.findRev(':' );
        if ( pos > 0 ) {
            QString mac = str.left(17 );
            str.remove( 0,  17 );
-            qWarning("mac %s",  mac.latin1() );
+            owarn << "mac " << mac.latin1() << oendl;
-            qWarning("rest:%s",  str.latin1() );
+            owarn << "rest: " << str.latin1() << oendl;
            RemoteDevice rem( mac , str.stripWhiteSpace() );
            list.append( rem );
        }
    }
    return list;
 }
 ////// hcitool cc and hcitool con
 /**
 * Create it on the stack as don't care
 * so we don't need to care for it
 * cause hcitool gets reparented
 */
 void Manager::connectTo( const QString& mac) {
    OProcess proc;
    proc << "hcitool";
    proc << "cc";
    proc << mac;
    proc.start(OProcess::DontCare); // the lib does not care at this point
 }
 void Manager::searchConnections() {
-    qWarning("searching connections?");
+    owarn << "searching connections?" << oendl;
    OProcess* proc = new OProcess();
    m_hcitoolCon = QString::null;
    connect(proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
            this, SLOT(slotConnectionExited( Opie::Core::OProcess*) ) );
    connect(proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
            this, SLOT(slotConnectionOutput(Opie::Core::OProcess*, char*, int) ) );
    *proc << "hcitool";
    *proc << "con";
    if (!proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
        ConnectionState::ValueList list;
        emit connections( list  );
        delete proc;
    }
 }
 void Manager::slotConnectionExited( OProcess* proc ) {
    ConnectionState::ValueList list;
    list = parseConnections( m_hcitoolCon );
    emit connections(list );
    delete proc;
 }
 void Manager::slotConnectionOutput(OProcess* /*proc*/, char* cha, int len) {
    QCString str(cha, len );
    m_hcitoolCon.append( str );
    //delete proc;
 }
 ConnectionState::ValueList Manager::parseConnections( const QString& out ) {
    ConnectionState::ValueList list2;
    QStringList list = QStringList::split('\n',  out );
    QStringList::Iterator it;
    // remove the first line ( "Connections:")
    it = list.begin();
    it = list.remove( it );
    for (; it != list.end(); ++it ) {
        QString row = (*it).stripWhiteSpace();
        QStringList value = QStringList::split(' ', row );
-        qWarning("0: %s", value[0].latin1() );
+        owan << "0: %s" << value[0].latin1() << oendl;
-        qWarning("1: %s", value[1].latin1() );
+        owan << "1: %s" << value[1].latin1() << oendl;
-        qWarning("2: %s", value[2].latin1() );
+        owan << "2: %s" << value[2].latin1() << oendl;
-        qWarning("3: %s", value[3].latin1() );
+        owan << "3: %s" << value[3].latin1() << oendl;
-        qWarning("4: %s", value[4].latin1() );
+        owan << "4: %s" << value[4].latin1() << oendl;
-        qWarning("5: %s", value[5].latin1() );
+        owan << "5: %s" << value[5].latin1() << oendl;
-        qWarning("6: %s", value[6].latin1() );
+        owan << "6: %s" << value[6].latin1() << oendl;
-        qWarning("7: %s", value[7].latin1() );
+        owan << "7: %s" << value[7].latin1() << oendl;
-        qWarning("8: %s", value[8].latin1() );
+        owan << "8: %s" << value[8].latin1() << oendl;
        ConnectionState con;
        con.setDirection( value[0] == QString::fromLatin1("<") ? Outgoing : Incoming );
        con.setConnectionMode( value[1] );
        con.setMac( value[2] );
        con.setHandle( value[4].toInt() );
        con.setState( value[6].toInt() );
        con.setLinkMode( value[8] == QString::fromLatin1("MASTER") ? Master : Client );
        list2.append( con );
    }
    return list2;
 }
 void Manager::signalStrength( const QString &mac ) {
    OProcess* sig_proc = new OProcess();
    connect(sig_proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
            this, SLOT(slotSignalStrengthExited( Opie::Core::OProcess*) ) );
    connect(sig_proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
            this, SLOT(slotSignalStrengthOutput(Opie::Core::OProcess*, char*, int) ) );
    *sig_proc << "hcitool";
    *sig_proc << "lq";
    *sig_proc << mac;
diff --git a/noncore/net/opietooth/lib/parser.cc b/noncore/net/opietooth/lib/parser.cc
index 8baf284..7e95907 100644
--- a/noncore/net/opietooth/lib/parser.cc
+++ b/noncore/net/opietooth/lib/parser.cc
@@ -1,199 +1,205 @@
+#include "parser.h"
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #include <qstringlist.h>
-#include "parser.h"
 using namespace OpieTooth;
 namespace {
    // "Test Foo Bar" (0x3456)
    // @param ret Test Foo Bar
    // @eturn 13398
    // tactic find " (
 int convert( const QString& line, QString& ret ) {
-//    qWarning("called");
+//    owarn << "called" << oendl;
    ret = QString::null;
    int i = 0;
    int pos = line.findRev("\" (");
    if ( pos > 0 ) { // it shouldn't be at pos 0
        ret = line.left(pos ).stripWhiteSpace();
-        //      qWarning("ret: %s",  ret.latin1() );
+        //      owarn << "ret: " << ret.latin1() << oendl;
        ret = ret.replace(QRegExp("[\"]"), "");
-        //qWarning("ret: %s", ret.latin1() );
+        //owarn << "ret: " << ret.latin1() << oendl;
        QString dummy = line.mid(pos + 5 );
-        //qWarning("dummy: %s",  dummy.latin1() );
+        //owarn << "dummy: " << dummy.latin1() << oendl;
        dummy = dummy.replace(QRegExp("[)]"), "");
-        //qWarning("dummy: %s", dummy.latin1() );
+        //owarn << "dummy: " << dummy.latin1() << oendl;
 //        dummy = dummy.remove( dummy.length() -2, 1 ); // remove the )
        bool ok;
        i = dummy.toInt(&ok, 16 );
        //if (ok ) {
-        //     qWarning("converted %d",  i);
+        //     owarn << "converted " << i << oendl;
-        //}else qWarning("failed" );
+        //}else owarn << "failed" << oendl;
-        //qWarning("exiting");
+        //owarn << "exiting" << oendl;
        return i;
    }
-    //qWarning("output %d", i );
+    //owarn << "output " << i << oendl;
    return i;
 }
 };
 Parser::Parser(const QString& output ) {
    parse( output );
 }
 void Parser::setText(const QString& output) {
    parse( output );
 }
 Services::ValueList Parser::services() const {
    return m_list;
 }
 void Parser::parse( const QString& string) {
    m_list.clear();
    m_complete = true;
    QStringList list = QStringList::split('\n', string,TRUE );
    QStringList::Iterator it;
    for (it = list.begin(); it != list.end(); ++it ) {
-        //qWarning("line:%s:line", (*it).latin1() );
+        //owarn << "line:" << (*it).latin1() << oendl;
        if ( (*it).startsWith("Browsing") ) continue;
        if ( (*it).stripWhiteSpace().isEmpty() ) { // line is empty because a new Service begins
-            qWarning("could add");
+            owarn << "could add" << oendl;
            // now see if complete and add
            if (m_complete ) {
                if (!m_item.serviceName().isEmpty() )
                    m_list.append( m_item );
                Services serv;
                m_item = serv;
                m_complete = true;
                continue;
            }
        }
        if (parseName(      (*it) ) ) ;//continue;
        if (parseRecHandle( (*it) ) ) ;//continue;
        if (parseClassId(   (*it) ) ) ;//continue;
        if (parseProtocol(  (*it) ) ) ;//continue;
        if (parseProfile(   (*it) ) ) ;//continue;
    }
    // missed the last one
    if (m_complete) {
-//        qWarning("adding");
+//        owarn << "adding" << oendl;
        if (!m_item.serviceName().isEmpty() )
            m_list.append(m_item );
    }
    QValueList<Services>::Iterator it2;
    if (m_list.isEmpty() )
-        qWarning("m_list is empty");
+        owarn << "m_list is empty" << oendl;
    for (it2 = m_list.begin(); it2 != m_list.end(); ++it2 ) {
-        qWarning("name %s", (*it2).serviceName().latin1() );
+        owarn << "name " << (*it2).serviceName().latin1() << oendl;
    }
 }
 bool Parser::parseName( const QString& str) {
    if (str.startsWith("Service Name:") ) {
        m_item.setServiceName( str.mid(13).stripWhiteSpace() );
-        qWarning(m_item.serviceName() );
+        owarn << m_item.serviceName() << oendl;
        return true;
    }
    return false;
 }
 bool Parser::parseRecHandle( const QString& str) {
    if (str.startsWith("Service RecHandle:" ) ) {
        QString out = str.mid(18 ).stripWhiteSpace();
-        qWarning("out %s", out.latin1() );
+        owarn << "out " << out.latin1() << oendl;
        int value = out.mid(2).toInt(&m_ok, 16 );
        if (m_ok && (value != -1) )
            m_complete = true;
        else
            m_complete = false;
-        qWarning("rec handle %d",  value);
+        owarn << "rec handle " << value << oendl;
        m_item.setRecHandle( value );
        return true;
    }
    return false;
 }
 bool Parser::parseClassId( const QString& str) {
    if (str.startsWith("Service Class ID List:") ) {
-        qWarning("found class id" );
+        owarn << "found class id" << oendl;
-        qWarning("line:%s", str.latin1() );
+        owarn << "line: " << str.latin1() << oendl;
        m_classOver = true;
        return true;
    }else if ( m_classOver && str.startsWith("  " )  ){ // ok now are the informations in place
-        qWarning("line with class id" );
+        owarn << "line with class id" << oendl;
-        qWarning("%s",str.latin1() );
+        owarn << str.latin1() << oendl;
        // "Obex Object Push" (0x1105)
        //  find backwards the " and the from 0 to pos and the mid pos+1
        // then stripWhiteSpace add name replace '"' with ""
        // and then convert 0x1105 toInt()
        QString classes;
        int ids;
        ids = convert( str, classes );
-        qWarning("ids %d", ids );
+        owarn << "ids " << ids << oendl;
        m_item.insertClassId( ids, classes );
        return true;
    }else{
-        qWarning("Else %d", m_classOver );
+        owarn << "Else " << m_classOver << oendl;
        m_classOver = false;
    }
    return false;
 }
 bool Parser::parseProtocol( const QString& str) {
    if (str.startsWith("Protocol Descriptor List:") ) {
        m_protocolOver = true;
        m_protocolAdded = false;
        return true;
    }else if (m_protocolOver && str.startsWith("  ") ) { // "L2CAP" (0x0100)
-        qWarning("double protocol filter");
+        owarn << "double protocol filter" << oendl;
        if (!m_protocolAdded ) { // the protocol does neither supply a channel nor port so add it now
            Services::ProtocolDescriptor desc(  m_protName,  m_protId );
            m_item.insertProtocolDescriptor( desc );
        }
        m_protocolAdded = false;
        { // the find function
            m_protId = convert(str, m_protName );
        }
        return true;
    }else if (m_protocolOver && str.startsWith("   ") ) {
-        qWarning("tripple protocol filter");
+        owarn << "tripple protocol filter" << oendl;
        m_protocolAdded = true;
        QString dummy = str.stripWhiteSpace();
        int pos = dummy.findRev(':');
        if ( pos > -1 ) {
            int port = dummy.mid(pos+1 ).stripWhiteSpace().toInt();
            Services::ProtocolDescriptor desc(  m_protName,  m_protId, port );
            m_item.insertProtocolDescriptor( desc );
        }
        return true;
    }else if (m_protocolOver ) {
        m_protocolOver = false;
    }
    return false;
 }
 bool Parser::parseProfile( const QString& str) {
    if (str.startsWith("Profile Descriptor List:") ) {
        m_profOver = true;
    }else if ( m_profOver && str.startsWith("  ") ) {
        m_profId = convert( str,  m_profName );
    }else if ( m_profOver && str.startsWith("   ") ) {
    //  now find
        int pos = str.findRev(':');
        if ( pos > 0 ) {
            int dummy = str.mid(pos+1 ).stripWhiteSpace().toInt();
-            qWarning("dummyInt:%d",  dummy );
+            owarn << "dummyInt: " << dummy << oendl;
            Services::ProfileDescriptor desc( m_profName, m_profId, dummy );
            m_item.insertProfileDescriptor(desc);
        }
    }else
        m_profOver = false;
    return false;
 }
diff --git a/noncore/settings/mediummount/mediumglobal.cc b/noncore/settings/mediummount/mediumglobal.cc
index ab0b3af..0c6cf12 100644
--- a/noncore/settings/mediummount/mediumglobal.cc
+++ b/noncore/settings/mediummount/mediumglobal.cc
@@ -1,38 +1,43 @@
+#include "mediumglobal.h"
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+#include <qpe/config.h>
+/* QT */
 #include <qlineedit.h>
 #include <qcheckbox.h>
 #include <qlabel.h>
 #include <qabstractlayout.h> // spacer item
 #include <qlayout.h>
 #include <qframe.h>
 #include <qgroupbox.h>
 #include <qwhatsthis.h>
-#include <qpe/config.h>
-#include "mediumglobal.h"
 using namespace MediumMountSetting;
 /* TRANSLATOR MediumMountSetting::MediumGlobalWidget */
 MediumGlobalWidget::MediumGlobalWidget(QWidget *wid, const char *name )
  : QWidget( wid, name, WStyle_ContextHelp )
 {
  m_config = 0;
  initGUI();
  readConfig();
 }
 void MediumGlobalWidget::initGUI()
 {
  m_layout = new QVBoxLayout(this );
   m_layout->setMargin( 4 );
  // m_layout->setSpacing( 10 );
  m_label = new QLabel( this );
  m_label->setTextFormat( Qt::RichText );
  m_label->setText( tr("") );
  QWhatsThis::add( this, tr("If a medium gets inserted into this device Opie "
@@ -131,49 +136,49 @@ void MediumGlobalWidget::writeConfig()
  m_config->setGroup( "main" );
  m_config->writeEntry("global", m_useglobal->isChecked() );
  m_config->writeEntry("use", m_check->isChecked() );
  m_config->setGroup("mimetypes" );
  m_config->writeEntry("all", m_all->isChecked() );
  m_config->writeEntry("audio", m_audio->isChecked() );
  m_config->writeEntry("video", m_video->isChecked() );
  m_config->writeEntry("text", m_text->isChecked() );
  m_config->writeEntry("image", m_image->isChecked() );
 }
 MediumGlobalWidget::~MediumGlobalWidget()
 {
  delete m_config;
 }
 void MediumGlobalWidget::slotGlobalChanged()
 {
  int mode = GLOBAL_DISABLED;
  bool enabled = false;
  if( ( enabled =m_useglobal->isChecked() ) ){
    mode = GLOBAL_ENABLED;
  }else
    mode = GLOBAL_DISABLED;
-  qWarning("enabled = %d", enabled );
+  owarn << "enabled = " << enabled << oendl;
  m_all->setEnabled  ( enabled );
  m_audio->setEnabled( enabled );
  m_image->setEnabled( enabled );
  m_text->setEnabled ( enabled );
  m_video->setEnabled ( enabled );
  slotAllChanged();
  emit globalStateChanged( mode );
 }
 void MediumGlobalWidget::slotEnableChecking()
 {
  int mode = ENABLE_CHECKS;
  bool enabled = false;
  if( ( enabled = m_check->isChecked() ) ){
    mode = ENABLE_CHECKS;
  }else{
    mode = DISABLE_CHECKS;
  }
  m_frame->setEnabled( enabled );
  slotGlobalChanged();
  emit enableStateChanged( mode );
 }
 void MediumGlobalWidget::slotAllChanged()
 {
diff --git a/noncore/styles/theme/othemebase.h b/noncore/styles/theme/othemebase.h
index e691692..5519798 100644
--- a/noncore/styles/theme/othemebase.h
+++ b/noncore/styles/theme/othemebase.h
@@ -1,739 +1,744 @@
 /* This file is part of the KDE libraries
  Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License version 2 as published by the Free Software Foundation.
  This library 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 Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to
  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA 02111-1307, USA.
 */
 #ifndef __OTHEMEBASE_H
 #define __OTHEMEBASE_H
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+/* QT */
 #include <qdatetime.h>
 #include <qtimer.h>
 #include <qwindowsstyle.h>
 #include <qpixmap.h>
 #include <qpe/config.h>
 #include <qimage.h>
 #include <qintcache.h>
 #include <qstring.h>
 #include <qpalette.h>
 #define WIDGETS 54
 /**
 * This class adds simple time management to QPixmap for use in flushing
 * OThemeCache.
 *
 * @author Daniel M. Duley <mosfet@kde.org>
 */
 class OThemePixmap : public QPixmap
 {
 public:
-        enum BorderType{Top = 0, Bottom, Left, Right, TopLeft, TopRight, BottomLeft,
+    enum BorderType{Top = 0, Bottom, Left, Right, TopLeft, TopRight, BottomLeft,
-                        BottomRight};
+                    BottomRight};
-        OThemePixmap( bool timer = true );
+    OThemePixmap( bool timer = true );
-        OThemePixmap( const OThemePixmap &p );
+    OThemePixmap( const OThemePixmap &p );
-        ~OThemePixmap();
+    ~OThemePixmap();
-        QPixmap* border( BorderType type );
+    QPixmap* border( BorderType type );
-        void setBorder( BorderType type, const QPixmap &p );
+    void setBorder( BorderType type, const QPixmap &p );
-        void updateAccessed();
+    void updateAccessed();
-        bool isOld();
+    bool isOld();
 protected:
-        QTime *t;
+    QTime *t;
-        QPixmap *b[ 8 ];
+    QPixmap *b[ 8 ];
 private:
-        class OThemePixmapPrivate;
+    class OThemePixmapPrivate;
-        OThemePixmapPrivate *d;
+    OThemePixmapPrivate *d;
 };
 inline QPixmap* OThemePixmap::border( BorderType type )
 {
-        return ( b[ type ] );
+    return ( b[ type ] );
 }
 inline void OThemePixmap::setBorder( BorderType type, const QPixmap &p )
 {
-        if ( b[ type ] ) {
+    if ( b[ type ] ) {
-                qWarning( "OThemePixmap: Overwriting existing border!" );
+        owarn << "OThemePixmap: Overwriting existing border!" << oendl;
-                delete( b[ type ] );
+        delete( b[ type ] );
-        }
+    }
-        b[ type ] = new QPixmap( p );
+    b[ type ] = new QPixmap( p );
 }
 inline void OThemePixmap::updateAccessed()
 {
-        if (t)
+    if (t)
-            t->start();
+        t->start();
 }
 inline bool OThemePixmap::isOld()
 {
-        return ( t ? t->elapsed() >= 300000 : false );
+    return ( t ? t->elapsed() >= 300000 : false );
 }
 /**
 * A very simple pixmap cache for theme plugins. QPixmapCache is not used
 * since it uses QString keys which are not needed. All the information we
 * need can be encoded in a numeric key. Using QIntCache instead allows us to
 * skip the string operations.
 *
 * This class is mostly just inline methods that do bit operations on a key
 * composed of the widget ID, width and/or height, and then calls
 * QIntCache::find().
 *
 * One other thing to note is that full, horizontal, and vertically scaled
 * pixmaps are not used interchangeably. For example, if you insert a fully
 * scaled pixmap that is 32x32 then request a horizontally scaled pixmap with
 * a width of 32, they will not match. This is because a pixmap that has been
 * inserted into the cache has already been scaled at some point and it is
 * very likely the vertical height was not originally 32. Thus the pixmap
 * will be wrong when drawn, even though the horizontal width matches.
 *
 * @author Daniel M. Duley <mosfet@kde.org>
 *
 */
 class OThemeCache : public QObject
 {
-        Q_OBJECT
+    Q_OBJECT
 public:
-        /**
+    /**
-         * The scale hints supported by the cache. Note that Tiled is not here
+     * The scale hints supported by the cache. Note that Tiled is not here
-         * since tiled pixmaps are kept only once in OThemeBase.
+     * since tiled pixmaps are kept only once in OThemeBase.
-         */
+     */
-        enum ScaleHint{FullScale, HorizontalScale, VerticalScale};
+    enum ScaleHint{FullScale, HorizontalScale, VerticalScale};
-        /**
+    /**
-         * The constructor.
+     * The constructor.
-         *
+     *
-         * @param maxSize The maximum size of the cache in kilobytes.
+     * @param maxSize The maximum size of the cache in kilobytes.
-         */
+     */
-        OThemeCache( int maxSize, QObject *parent = 0, const char *name = 0 );
+    OThemeCache( int maxSize, QObject *parent = 0, const char *name = 0 );
-        /**
+    /**
-         * Inserts a new pixmap into the cache.
+     * Inserts a new pixmap into the cache.
-         *
+     *
-         * @param pixmap The pixmap to insert.
+     * @param pixmap The pixmap to insert.
-         * @param scale The scaling type of the pixmap.
+     * @param scale The scaling type of the pixmap.
-         * @param widgetID The widget ID of the pixmap, usually from OThemeBase's
+     * @param widgetID The widget ID of the pixmap, usually from OThemeBase's
-         * WidgetType enum.
+     * WidgetType enum.
-         *
+     *
-         * @return True if the insert was successful, false otherwise.
+     * @return True if the insert was successful, false otherwise.
-         */
+     */
-        bool insert( OThemePixmap *pixmap, ScaleHint scale, int widgetID,
+    bool insert( OThemePixmap *pixmap, ScaleHint scale, int widgetID,
-                     bool border = false, bool mask = false );
+                 bool border = false, bool mask = false );
-        /**
+    /**
-         * Returns a fully scaled pixmap.
+     * Returns a fully scaled pixmap.
-         *
+     *
-         * @param w The pixmap width to search for.
+     * @param w The pixmap width to search for.
-         * @param h The pixmap height to search for.
+     * @param h The pixmap height to search for.
-         * @param widgetID The widget ID to search for.
+     * @param widgetID The widget ID to search for.
-         *
+     *
-         * @return True if a pixmap matching the width, height, and widget ID of
+     * @return True if a pixmap matching the width, height, and widget ID of
-         * the pixmap exists, NULL otherwise.
+     * the pixmap exists, NULL otherwise.
-         */
+     */
-        OThemePixmap* pixmap( int w, int h, int widgetID, bool border = false,
+    OThemePixmap* pixmap( int w, int h, int widgetID, bool border = false,
-                              bool mask = false );
+                          bool mask = false );
-        /**
+    /**
-         * Returns a horizontally scaled pixmap.
+     * Returns a horizontally scaled pixmap.
-         *
+     *
-         * @param w The pixmap width to search for.
+     * @param w The pixmap width to search for.
-         * @param widgetID The widget ID to search for.
+     * @param widgetID The widget ID to search for.
-         *
+     *
-         * @return True if a pixmap matching the width and widget ID of
+     * @return True if a pixmap matching the width and widget ID of
-         * the pixmap exists, NULL otherwise.
+     * the pixmap exists, NULL otherwise.
-         */
+     */
-        OThemePixmap* horizontalPixmap( int w, int widgetID );
+    OThemePixmap* horizontalPixmap( int w, int widgetID );
-        /**
+    /**
-         * Returns a vertically scaled pixmap.
+     * Returns a vertically scaled pixmap.
-         *
+     *
-         * @param h The pixmap height to search for.
+     * @param h The pixmap height to search for.
-         * @param widgetID The widget ID to search for.
+     * @param widgetID The widget ID to search for.
-         *
+     *
-         * @return True if a pixmap matching the height and widget ID of
+     * @return True if a pixmap matching the height and widget ID of
-         * the pixmap exists, NULL otherwise.
+     * the pixmap exists, NULL otherwise.
-         */
+     */
-        OThemePixmap* verticalPixmap( int h, int widgetID );
+    OThemePixmap* verticalPixmap( int h, int widgetID );
 protected slots:
-        void flushTimeout();
+    void flushTimeout();
 protected:
-        QIntCache<OThemePixmap> cache;
+    QIntCache<OThemePixmap> cache;
-        QTimer flushTimer;
+    QTimer flushTimer;
 private:
-        class OThemeCachePrivate;
+    class OThemeCachePrivate;
-        OThemeCachePrivate *d;
+    OThemeCachePrivate *d;
 };
 /**
 * This is a base class for KDE themed styles. It implements a cache,
 * configuration file parsing, pixmap scaling, gradients, and a lot
 * of inline methods for accessing user specified parameters.
 *
 * Note that this class *does not* actually implement any themes. It just
 * provides the groundwork for doing so. The only reason to use this class
 * directly is if you plan to reimplement all of the widgets. Otherwise,
 * refer to OThemeStyle for a fully themed style you can derive from.
 *
 * @author Daniel M. Duley <mosfet@kde.org>
 */
 class OThemeBase: public QWindowsStyle
 {
-        Q_OBJECT
+    Q_OBJECT
 public:
-        /**
+    /**
-         * Constructs a new OThemeBase object.
+     * Constructs a new OThemeBase object.
-         */
+     */
-        OThemeBase( const QString &configFile );
+    OThemeBase( const QString &configFile );
-        ~OThemeBase();
+    ~OThemeBase();
-        /**
+    /**
-         * Describes if a pixmap should be scaled fully, horizontally, vertically,
+     * Describes if a pixmap should be scaled fully, horizontally, vertically,
-         * or not at all and tiled.
+     * or not at all and tiled.
-         */
+     */
-        enum ScaleHint{FullScale, HorizontalScale, VerticalScale, TileScale};
+    enum ScaleHint{FullScale, HorizontalScale, VerticalScale, TileScale};
-        /**
+    /**
-         * The default arrow types.
+     * The default arrow types.
-         */
+     */
-        enum ArrowStyle{MotifArrow, LargeArrow, SmallArrow};
+    enum ArrowStyle{MotifArrow, LargeArrow, SmallArrow};
-        /**
+    /**
-         * The default frame shading styles.
+     * The default frame shading styles.
-         */
+     */
-        enum ShadeStyle{Motif, Windows, Next, KDE};
+    enum ShadeStyle{Motif, Windows, Next, KDE};
-        /**
+    /**
-         * The default scrollbar button layout. BottomLeft is like what Next
+     * The default scrollbar button layout. BottomLeft is like what Next
-         * uses, BottomRight is like Platinum, and Opposite it like Windows and
+     * uses, BottomRight is like Platinum, and Opposite it like Windows and
-         * Motif.
+     * Motif.
-         */
+     */
-        enum SButton{SBBottomLeft, SBBottomRight, SBOpposite};
+    enum SButton{SBBottomLeft, SBBottomRight, SBOpposite};
-        /**
+    /**
-         * The gradient types. Horizontal is left to right, Vertical is top to
+     * The gradient types. Horizontal is left to right, Vertical is top to
-         * bottom, and diagonal is upper-left to bottom-right.
+     * bottom, and diagonal is upper-left to bottom-right.
-         */
+     */
-        enum Gradient{GrNone, GrHorizontal, GrVertical, GrDiagonal, GrPyramid,
+    enum Gradient{GrNone, GrHorizontal, GrVertical, GrDiagonal, GrPyramid,
-                      GrRectangle, GrElliptic, GrReverseBevel};
+                  GrRectangle, GrElliptic, GrReverseBevel};
-        /**
+    /**
-         * This provides a list of widget types that OThemeBase recognizes.
+     * This provides a list of widget types that OThemeBase recognizes.
-         */
+     */
-        /* Internal note: The order here is important. Some widgets inherit
+    /* Internal note: The order here is important. Some widgets inherit
-         * properties. This is usually for when you have two settings for the
+     * properties. This is usually for when you have two settings for the
-         * same widget, ie: on(sunken), and off. The on settings will inherit
+     * same widget, ie: on(sunken), and off. The on settings will inherit
-         * the properties of the off one when nothing is specified in the config.
+     * the properties of the off one when nothing is specified in the config.
-         *
+     *
-         * In order to be able to handle this while still having everything in
+     * In order to be able to handle this while still having everything in
-         * one group that is easy to loop from we have the following order:
+     * one group that is easy to loop from we have the following order:
-         * unsunked(off) items, sunken(on)items, and then the ones that don't
+     * unsunked(off) items, sunken(on)items, and then the ones that don't
-         * matter. INHERIT_ITEMS define the number of widgets that have inheritence
+     * matter. INHERIT_ITEMS define the number of widgets that have inheritence
-         * so if 0 == PushButtonOff then INHERIT_ITEMS should == PushButtonOn
+     * so if 0 == PushButtonOff then INHERIT_ITEMS should == PushButtonOn
-         * and so on. WIDGETS define the total number of widgets.
+     * and so on. WIDGETS define the total number of widgets.
-         */
+     */
-        enum WidgetType{
+    enum WidgetType{
-            // Off (unsunken widgets)
+        // Off (unsunken widgets)
-            PushButton = 0, ComboBox, HScrollBarSlider, VScrollBarSlider, Bevel,
+        PushButton = 0, ComboBox, HScrollBarSlider, VScrollBarSlider, Bevel,
-            ToolButton, ScrollButton, HScrollDeco, VScrollDeco,
+        ToolButton, ScrollButton, HScrollDeco, VScrollDeco,
-            ComboDeco, MenuItem, InactiveTab, ArrowUp, ArrowDown, ArrowLeft,
+        ComboDeco, MenuItem, InactiveTab, ArrowUp, ArrowDown, ArrowLeft,
-            ArrowRight,
+        ArrowRight,
-            // On (sunken widgets)
+        // On (sunken widgets)
-            PushButtonDown, ComboBoxDown, HScrollBarSliderDown,
+        PushButtonDown, ComboBoxDown, HScrollBarSliderDown,
-            VScrollBarSliderDown, BevelDown, ToolButtonDown, ScrollButtonDown,
+        VScrollBarSliderDown, BevelDown, ToolButtonDown, ScrollButtonDown,
-            HScrollDecoDown, VScrollDecoDown, ComboDecoDown, MenuItemDown,
+        HScrollDecoDown, VScrollDecoDown, ComboDecoDown, MenuItemDown,
-            ActiveTab, SunkenArrowUp, SunkenArrowDown, SunkenArrowLeft,
+        ActiveTab, SunkenArrowUp, SunkenArrowDown, SunkenArrowLeft,
-            SunkenArrowRight,
+        SunkenArrowRight,
-            // Everything else (indicators must have separate settings)
+        // Everything else (indicators must have separate settings)
-            HScrollGroove, VScrollGroove, Slider, SliderGroove, IndicatorOn,
+        HScrollGroove, VScrollGroove, Slider, SliderGroove, IndicatorOn,
-            IndicatorOff, ExIndicatorOn, ExIndicatorOff, HBarHandle, VBarHandle,
+        IndicatorOff, ExIndicatorOn, ExIndicatorOff, HBarHandle, VBarHandle,
-            ToolBar, Splitter, CheckMark, MenuBar, DisArrowUp, DisArrowDown,
+        ToolBar, Splitter, CheckMark, MenuBar, DisArrowUp, DisArrowDown,
-            DisArrowLeft, DisArrowRight, ProgressBar, ProgressBg, MenuBarItem,
+        DisArrowLeft, DisArrowRight, ProgressBar, ProgressBg, MenuBarItem,
-            Background};
+        Background};
-        /**
+    /**
-         * The scaling type specified by the Config file.
+     * The scaling type specified by the Config file.
-         *
+     *
-         * @param widget A Widgets enum value.
+     * @param widget A Widgets enum value.
-         *
+     *
-         * @return A ScaleHint enum value.
+     * @return A ScaleHint enum value.
-         */
+     */
-        ScaleHint scaleHint( WidgetType widget ) const;
+    ScaleHint scaleHint( WidgetType widget ) const;
-        /**
+    /**
-         * The gradient type specified by the KConfig file.
+     * The gradient type specified by the KConfig file.
-         *
+     *
-         * @param widget A Widgets enum value.
+     * @param widget A Widgets enum value.
-         *
+     *
-         * @return A Gradient enum value.
+     * @return A Gradient enum value.
-         */
+     */
-        Gradient gradientHint( WidgetType widget ) const;
+    Gradient gradientHint( WidgetType widget ) const;
-        /**
+    /**
-         * The color group specified for a given widget.
+     * The color group specified for a given widget.
-         * If a color group is set in the theme configuration
+     * If a color group is set in the theme configuration
-         * that is used, otherwise defaultColor is returned.
+     * that is used, otherwise defaultColor is returned.
-         *
+     *
-         * @param defaultColor The colorGroup to set if one is available.
+     * @param defaultColor The colorGroup to set if one is available.
-         *
+     *
-         * @param widget The widget whose color group to retrieve.
+     * @param widget The widget whose color group to retrieve.
-         *
+     *
-         */
+     */
-        const QColorGroup* colorGroup( const QColorGroup &defaultGroup,
+    const QColorGroup* colorGroup( const QColorGroup &defaultGroup,
-                                       WidgetType widget ) const;
+                                   WidgetType widget ) const;
-        QBrush pixmapBrush( const QColorGroup &group, QColorGroup::ColorRole role,
+    QBrush pixmapBrush( const QColorGroup &group, QColorGroup::ColorRole role,
-                            int w, int h, WidgetType widget );
+                        int w, int h, WidgetType widget );
-        /**
+    /**
-         * True if the widget has a pixmap or gradient specified.
+     * True if the widget has a pixmap or gradient specified.
-         */
+     */
-        bool isPixmap( WidgetType widget ) const;
+    bool isPixmap( WidgetType widget ) const;
-        /**
+    /**
-         * True if the widget has a color group specified.
+     * True if the widget has a color group specified.
-         */
+     */
-        bool isColor( WidgetType widget ) const;
+    bool isColor( WidgetType widget ) const;
-        /**
+    /**
-         * True if the user specified a 3D focus rectangle
+     * True if the user specified a 3D focus rectangle
-         */
+     */
-        bool is3DFocus() const;
+    bool is3DFocus() const;
-        /**
+    /**
-         * If the user specified a 3D focus rectangle, they may also specify an
+     * If the user specified a 3D focus rectangle, they may also specify an
-         * offset from the default rectangle to use when drawing it. This returns
+     * offset from the default rectangle to use when drawing it. This returns
-         * the specified offset.
+     * the specified offset.
-         */
+     */
-        int focusOffset() const;
+    int focusOffset() const;
-        /**
+    /**
-         * The border width of the specified widget.
+     * The border width of the specified widget.
-         */
+     */
-        int borderWidth( WidgetType widget ) const;
+    int borderWidth( WidgetType widget ) const;
-        /**
+    /**
-         * Pixmap border width of the specified widget.
+     * Pixmap border width of the specified widget.
-         */
+     */
-        int pixBorderWidth( WidgetType widget ) const;
+    int pixBorderWidth( WidgetType widget ) const;
-        /**
+    /**
-         * Returns the border pixmap if enabled for the specified widget. This
+     * Returns the border pixmap if enabled for the specified widget. This
-         * will contain the originial pixmap, plus the edges separated in
+     * will contain the originial pixmap, plus the edges separated in
-         * OThemePixmap::border() if valid. If invalid it will return NULL.
+     * OThemePixmap::border() if valid. If invalid it will return NULL.
-         */
+     */
-        OThemePixmap* borderPixmap( WidgetType widget );
+    OThemePixmap* borderPixmap( WidgetType widget );
-        /**
+    /**
-         * The highlight width of the specified widget.
+     * The highlight width of the specified widget.
-         */
+     */
-        int highlightWidth( WidgetType widget ) const;
+    int highlightWidth( WidgetType widget ) const;
-        /**
+    /**
-         * The border plus highlight width of the widget.
+     * The border plus highlight width of the widget.
-         */
+     */
-        int decoWidth( WidgetType widget ) const;
+    int decoWidth( WidgetType widget ) const;
-        /**
+    /**
-         * The extent (width for vertical, height for horizontal) requested
+     * The extent (width for vertical, height for horizontal) requested
-         * for the scrollbars.
+     * for the scrollbars.
-         */
+     */
-        int getSBExtent() const;
+    int getSBExtent() const;
-        /**
+    /**
-         * The scrollbar button layout.
+     * The scrollbar button layout.
-         */
+     */
-        SButton scrollBarLayout() const;
+    SButton scrollBarLayout() const;
-        /**
+    /**
-         * The arrow type.
+     * The arrow type.
-         */
+     */
-        ArrowStyle arrowType() const;
+    ArrowStyle arrowType() const;
-        /**
+    /**
-         * The shading type.
+     * The shading type.
-         */
+     */
-        ShadeStyle shade() const;
+    ShadeStyle shade() const;
-        /**
+    /**
-         * The frame width.
+     * The frame width.
-         */
+     */
-        int frameWidth() const;
+    int frameWidth() const;
-        /**
+    /**
-         * The splitter width.
+     * The splitter width.
-         */
+     */
-        int splitWidth() const;
+    int splitWidth() const;
-        /**
+    /**
-         * The contrast for some bevel effects such as reverse gradient.
+     * The contrast for some bevel effects such as reverse gradient.
-         */
+     */
-        int bevelContrast( WidgetType widget ) const;
+    int bevelContrast( WidgetType widget ) const;
-        /**
+    /**
-         * The button text X shift.
+     * The button text X shift.
-         */
+     */
-        int buttonXShift() const;
+    int buttonXShift() const;
-        /**
+    /**
-         * The button text Y shift.
+     * The button text Y shift.
-         */
+     */
-        int buttonYShift() const;
+    int buttonYShift() const;
-        /**
+    /**
-         * Returns either the slider length of the slider pixmap if available,
+     * Returns either the slider length of the slider pixmap if available,
-         * otherwise the length specified in the config file.
+     * otherwise the length specified in the config file.
-         */
+     */
-        int sliderButtonLength() const;
+    int sliderButtonLength() const;
-        /**
+    /**
-         * True if rounded buttons are requested.
+     * True if rounded buttons are requested.
-         */
+     */
-        bool roundButton() const;
+    bool roundButton() const;
-        /**
+    /**
-         * True if rounded comboboxes are requested.
+     * True if rounded comboboxes are requested.
-         */
+     */
-        bool roundComboBox() const;
+    bool roundComboBox() const;
-        /**
+    /**
-         * True if rounded slider grooves are requested.
+     * True if rounded slider grooves are requested.
-         */
+     */
-        bool roundSlider() const;
+    bool roundSlider() const;
-        /**
+    /**
-         * True if a line should be drawn on the bottom of active tabs.
+     * True if a line should be drawn on the bottom of active tabs.
-         */
+     */
-        bool activeTabLine() const;
+    bool activeTabLine() const;
-        /**
+    /**
-         * True if a line should be drawn on the bottom of inactive tabs.
+     * True if a line should be drawn on the bottom of inactive tabs.
-         */
+     */
-        bool inactiveTabLine() const;
+    bool inactiveTabLine() const;
-        /**
+    /**
-         * Returns the current uncached pixmap for the given widget. This will
+     * Returns the current uncached pixmap for the given widget. This will
-         * usually be either the last scaled or gradient pixmap if those have
+     * usually be either the last scaled or gradient pixmap if those have
-         * been specified in the config file, the original pixmap if not, or NULL
+     * been specified in the config file, the original pixmap if not, or NULL
-         * if no pixmap has been specified.
+     * if no pixmap has been specified.
-         */
+     */
-        OThemePixmap* uncached( WidgetType widget ) const;
+    OThemePixmap* uncached( WidgetType widget ) const;
-        /**
+    /**
-         * Returns the pixmap for the given widget at the specified width and
+     * Returns the pixmap for the given widget at the specified width and
-         * height. This will return NULL if no pixmap or gradient is specified.
+     * height. This will return NULL if no pixmap or gradient is specified.
-         * It may also return a different sized pixmap if the scaling
+     * It may also return a different sized pixmap if the scaling
-         * is set to Tiled. When using this method, you should call it using
+     * is set to Tiled. When using this method, you should call it using
-         * the needed width and height then use QPainter::drawTiledPixmap to
+     * the needed width and height then use QPainter::drawTiledPixmap to
-         * paint it. Doing this, if the pixmap is scaled it will be the proper
+     * paint it. Doing this, if the pixmap is scaled it will be the proper
-         * size, otherwise it will be tiled.
+     * size, otherwise it will be tiled.
-         *
+     *
-         * @param w Requested width.
+     * @param w Requested width.
-         * @param h Requested height.
+     * @param h Requested height.
-         * @param widget Widget type.
+     * @param widget Widget type.
-         * @return The pixmap or NULL if one is not specified.
+     * @return The pixmap or NULL if one is not specified.
-         */
+     */
-        virtual OThemePixmap *scalePixmap( int w, int h, WidgetType widget );
+    virtual OThemePixmap *scalePixmap( int w, int h, WidgetType widget );
-        /**
+    /**
-         * This method reads a configuration file and applies it to the user's
+     * This method reads a configuration file and applies it to the user's
-         * kstylerc file. It does not signal applications to reload via the
+     * kstylerc file. It does not signal applications to reload via the
-         * KDEChangeGeneral atom, if you want to do this you must do so yourself.
+     * KDEChangeGeneral atom, if you want to do this you must do so yourself.
-         * See kcmdisplay's general.cpp for an example.
+     * See kcmdisplay's general.cpp for an example.
-         *
+     *
-         * @param file The configuration file to apply.
+     * @param file The configuration file to apply.
-         */
+     */
-        static void applyConfigFile( const QString &file );
+    static void applyConfigFile( const QString &file );
 protected:
-        /**
+    /**
-         * Returns a QImage for the given widget if the widget is scaled, NULL
+     * Returns a QImage for the given widget if the widget is scaled, NULL
-         * otherwise. QImages of the original pixmap are stored for scaled
+     * otherwise. QImages of the original pixmap are stored for scaled
-         * widgets in order to facilitate fast and accurate smooth-scaling. This
+     * widgets in order to facilitate fast and accurate smooth-scaling. This
-         * also saves us a conversion from a pixmap to an image then back again.
+     * also saves us a conversion from a pixmap to an image then back again.
-         */
+     */
-        QImage* image( WidgetType widget ) const;
+    QImage* image( WidgetType widget ) const;
-        /**
+    /**
-         * Returns the gradient high color if one is specified, NULL otherwise.
+     * Returns the gradient high color if one is specified, NULL otherwise.
-         */
+     */
-        QColor* gradientHigh( WidgetType widget ) const;
+    QColor* gradientHigh( WidgetType widget ) const;
-        /**
+    /**
-         * Returns the gradient low color if one is specified, NULL otherwise.
+     * Returns the gradient low color if one is specified, NULL otherwise.
-         */
+     */
-        QColor* gradientLow( WidgetType widget ) const;
+    QColor* gradientLow( WidgetType widget ) const;
-        /**
+    /**
-         * Reads in all the configuration file entries supported.
+     * Reads in all the configuration file entries supported.
-         *
+     *
-         * @param colorStyle The style for the color groups. In KDE, colors were
+     * @param colorStyle The style for the color groups. In KDE, colors were
-         * calculated a little differently for Motif vs Windows styles. This
+     * calculated a little differently for Motif vs Windows styles. This
-         * is obsolete.
+     * is obsolete.
-         */
+     */
-        void readConfig( Qt::GUIStyle colorStyle = Qt::WindowsStyle );
+    void readConfig( Qt::GUIStyle colorStyle = Qt::WindowsStyle );
-        void readWidgetConfig( int i, Config *config, QString *pixnames,
+    void readWidgetConfig( int i, Config *config, QString *pixnames,
-                               QString *brdnames, bool *loadArray );
+                           QString *brdnames, bool *loadArray );
-        void copyWidgetConfig( int sourceID, int destID, QString *pixnames,
+    void copyWidgetConfig( int sourceID, int destID, QString *pixnames,
-                               QString *brdnames );
+                           QString *brdnames );
-        /**
+    /**
-         * Makes a full color group based on the given foreground and background
+     * Makes a full color group based on the given foreground and background
-         * colors. This is the same code used by KDE (kapp.cpp) in previous
+     * colors. This is the same code used by KDE (kapp.cpp) in previous
-         * versions.
+     * versions.
-         */
+     */
-        QColorGroup* makeColorGroup( QColor &fg, QColor &bg,
+    QColorGroup* makeColorGroup( QColor &fg, QColor &bg,
-                                     Qt::GUIStyle style = Qt::WindowsStyle );
+                                 Qt::GUIStyle style = Qt::WindowsStyle );
-        OThemePixmap* scale( int w, int h, WidgetType widget );
+    OThemePixmap* scale( int w, int h, WidgetType widget );
-        OThemePixmap* scaleBorder( int w, int h, WidgetType type );
+    OThemePixmap* scaleBorder( int w, int h, WidgetType type );
-        OThemePixmap* gradient( int w, int h, WidgetType widget );
+    OThemePixmap* gradient( int w, int h, WidgetType widget );
-        OThemePixmap* blend( WidgetType widget );
+    OThemePixmap* blend( WidgetType widget );
-        void generateBorderPix( int i );
+    void generateBorderPix( int i );
-        void applyResourceGroup( Config *config, int i, QString *copyfrom, QString *pixnames, QString *brdnames );
+    void applyResourceGroup( Config *config, int i, QString *copyfrom, QString *pixnames, QString *brdnames );
-        void applyMiscResourceGroup( Config *config );
+    void applyMiscResourceGroup( Config *config );
-        void readResourceGroup( int i, QString *copyfrom, QString *pixnames, QString *brdnames,
+    void readResourceGroup( int i, QString *copyfrom, QString *pixnames, QString *brdnames,
-                                bool *loadArray );
+                            bool *loadArray );
-        void readMiscResourceGroup();
+    void readMiscResourceGroup();
-        /**
+    /**
-         * Attempts to load a pixmap from the default OThemeBase locations.
+     * Attempts to load a pixmap from the default OThemeBase locations.
-         */
+     */
-        OThemePixmap* loadPixmap( QString &name );
+    OThemePixmap* loadPixmap( QString &name );
-        /**
+    /**
-         * Attempts to load a image from the default OThemeBase locations.
+     * Attempts to load a image from the default OThemeBase locations.
-         */
+     */
-        QImage* loadImage( QString &name );
+    QImage* loadImage( QString &name );
 private:
-        SButton sbPlacement;
+    SButton sbPlacement;
-        ArrowStyle arrowStyle;
+    ArrowStyle arrowStyle;
-        ShadeStyle shading;
+    ShadeStyle shading;
-        int defaultFrame;
+    int defaultFrame;
-        int btnXShift, btnYShift;
+    int btnXShift, btnYShift;
-        int sliderLen;
+    int sliderLen;
-        int splitterWidth;
+    int splitterWidth;
-        int focus3DOffset;
+    int focus3DOffset;
-        int sbExtent;
+    int sbExtent;
-        bool smallGroove;
+    bool smallGroove;
-        bool roundedButton, roundedCombo, roundedSlider;
+    bool roundedButton, roundedCombo, roundedSlider;
-        bool aTabLine, iTabLine;
+    bool aTabLine, iTabLine;
-        bool focus3D;
+    bool focus3D;
-        OThemeCache *cache;
+    OThemeCache *cache;
-        int cacheSize;
+    int cacheSize;
-        QString configFileName;
+    QString configFileName;
-        QString configFilePath;
+    QString configFilePath;
 protected:
-        QColor fgcolor, bgcolor, selfgcolor, selbgcolor, winfgcolor, winbgcolor;
+    QColor fgcolor, bgcolor, selfgcolor, selbgcolor, winfgcolor, winbgcolor;
 private:
-        /**
+    /**
-         * The theme pixmaps. Many of these may be NULL if no pixmap is specified.
+     * The theme pixmaps. Many of these may be NULL if no pixmap is specified.
-         * There may also be duplicate pixmap pointers if more than one widget
+     * There may also be duplicate pixmap pointers if more than one widget
-         * uses the same tiled pixmap. If a pixmap is tiled, it is kept here and
+     * uses the same tiled pixmap. If a pixmap is tiled, it is kept here and
-         * this acts as a cache. Otherwise this will hold whatever the last scaled
+     * this acts as a cache. Otherwise this will hold whatever the last scaled
-         * pixmap was.
+     * pixmap was.
-         */
+     */
-        OThemePixmap *pixmaps[ WIDGETS ];
+    OThemePixmap *pixmaps[ WIDGETS ];
-        /**
+    /**
-         * The theme images. These are for scaled images and are kept in order
+     * The theme images. These are for scaled images and are kept in order
-         * to maintain fast smoothscaling.
+     * to maintain fast smoothscaling.
-         */
+     */
-        QImage *images[ WIDGETS ];
+    QImage *images[ WIDGETS ];
-        /**
+    /**
-         * The border widths
+     * The border widths
-         */
+     */
-        unsigned char borders[ WIDGETS ];
+    unsigned char borders[ WIDGETS ];
-        /**
+    /**
-         * The highlight widths
+     * The highlight widths
-         */
+     */
-        unsigned char highlights[ WIDGETS ];
+    unsigned char highlights[ WIDGETS ];
-        /**
+    /**
-         * The scale hints for pixmaps and gradients.
+     * The scale hints for pixmaps and gradients.
-         */
+     */
-        ScaleHint scaleHints[ WIDGETS ];
+    ScaleHint scaleHints[ WIDGETS ];
-        /**
+    /**
-         * All the color groups.
+     * All the color groups.
-         */
+     */
-        QColorGroup *colors[ WIDGETS ];
+    QColorGroup *colors[ WIDGETS ];
-        /**
+    /**
-         * Gradient low colors (or blend background).
+     * Gradient low colors (or blend background).
-         */
+     */
-        QColor *grLowColors[ WIDGETS ];
+    QColor *grLowColors[ WIDGETS ];
-        /**
+    /**
-         * Gradient high colors.
+     * Gradient high colors.
-         */
+     */
-        QColor *grHighColors[ WIDGETS ];
+    QColor *grHighColors[ WIDGETS ];
-        /**
+    /**
-         * Gradient types.
+     * Gradient types.
-         */
+     */
-        Gradient gradients[ WIDGETS ];
+    Gradient gradients[ WIDGETS ];
-        /**
+    /**
-         * Blend intensity factors
+     * Blend intensity factors
-         */
+     */
-        float blends[ WIDGETS ];
+    float blends[ WIDGETS ];
-        /**
+    /**
-         * Bevel contrasts
+     * Bevel contrasts
-         */
+     */
-        unsigned char bContrasts[ WIDGETS ];
+    unsigned char bContrasts[ WIDGETS ];
-        /**
+    /**
-         * Duplicate pixmap entries (used during destruction).
+     * Duplicate pixmap entries (used during destruction).
-         */
+     */
-        bool duplicate[ WIDGETS ];
+    bool duplicate[ WIDGETS ];
-        /**
+    /**
-         * Pixmapped border widths
+     * Pixmapped border widths
-         */
+     */
-        int pbWidth[ WIDGETS ];
+    int pbWidth[ WIDGETS ];
-        /**
+    /**
-         * Pixmapped borders
+     * Pixmapped borders
-         */
+     */
-        OThemePixmap *pbPixmaps[ WIDGETS ];
+    OThemePixmap *pbPixmaps[ WIDGETS ];
-        /**
+    /**
-         * Duplicate border pixmapped border entries
+     * Duplicate border pixmapped border entries
-         */
+     */
-        bool pbDuplicate[ WIDGETS ];
+    bool pbDuplicate[ WIDGETS ];
 private:
-        class OThemeBasePrivate;
+    class OThemeBasePrivate;
-        OThemeBasePrivate *d;
+    OThemeBasePrivate *d;
 };
 inline bool OThemeBase::isPixmap( WidgetType widget ) const
 {
-        return ( pixmaps[ widget ] != NULL || gradients[ widget ] != GrNone );
+    return ( pixmaps[ widget ] != NULL || gradients[ widget ] != GrNone );
 }
 inline bool OThemeBase::isColor( WidgetType widget ) const
 {
-        return ( colors[ widget ] != NULL );
+    return ( colors[ widget ] != NULL );
 }
 inline bool OThemeBase::is3DFocus() const
 {
-        return ( focus3D );
+    return ( focus3D );
 }
 inline int OThemeBase::focusOffset() const
 {
-        return ( focus3DOffset );
+    return ( focus3DOffset );
 }
 inline int OThemeBase::bevelContrast( WidgetType widget ) const
 {
-        return ( bContrasts[ widget ] );
+    return ( bContrasts[ widget ] );
 }
 inline OThemeBase::ScaleHint OThemeBase::scaleHint( WidgetType widget ) const
 {
-        return ( ( widget < WIDGETS ) ? scaleHints[ widget ] : TileScale );
+    return ( ( widget < WIDGETS ) ? scaleHints[ widget ] : TileScale );
 }
 inline OThemeBase::Gradient OThemeBase::gradientHint( WidgetType widget ) const
 {
-        return ( ( widget < WIDGETS ) ? gradients[ widget ] : GrNone );
+    return ( ( widget < WIDGETS ) ? gradients[ widget ] : GrNone );
 }
 inline OThemePixmap* OThemeBase::uncached( WidgetType widget ) const
 {
-        return ( pixmaps[ widget ] );
+    return ( pixmaps[ widget ] );
 }
 inline QBrush OThemeBase::pixmapBrush( const QColorGroup &group,
                                       QColorGroup::ColorRole role,
                                       int w, int h, WidgetType widget )
 {
-        if ( pixmaps[ widget ] || images[ widget ] )
+    if ( pixmaps[ widget ] || images[ widget ] )
-                return ( QBrush( group.color( role ), *scalePixmap( w, h, widget ) ) );
+        return ( QBrush( group.color( role ), *scalePixmap( w, h, widget ) ) );
-        else
+    else
-                return ( group.color( role ) );
+        return ( group.color( role ) );
 }
 inline const QColorGroup* OThemeBase::colorGroup( const QColorGroup &defaultGroup,
        WidgetType widget ) const
 {
-        return ( ( colors[ widget ] ) ? colors[ widget ] : &defaultGroup );
+    return ( ( colors[ widget ] ) ? colors[ widget ] : &defaultGroup );
 }
 inline int OThemeBase::borderWidth( WidgetType widget ) const
 {
-        return ( pbWidth[ widget ] ? pbWidth[ widget ] : borders[ widget ] );
+    return ( pbWidth[ widget ] ? pbWidth[ widget ] : borders[ widget ] );
 }
 inline int OThemeBase::pixBorderWidth( WidgetType widget ) const
 {
-        return ( pbWidth[ widget ] );
+    return ( pbWidth[ widget ] );
 }
 inline int OThemeBase::highlightWidth( WidgetType widget ) const
 {
-        return ( pbWidth[ widget ] ? 0 : highlights[ widget ] );
+    return ( pbWidth[ widget ] ? 0 : highlights[ widget ] );
 }
 inline int OThemeBase::decoWidth( WidgetType widget ) const
 {
-        return ( pbWidth[ widget ] ? pbWidth[ widget ] : borders[ widget ] + highlights[ widget ] );
+    return ( pbWidth[ widget ] ? pbWidth[ widget ] : borders[ widget ] + highlights[ widget ] );
 }
 inline QColor* OThemeBase::gradientHigh( WidgetType widget ) const
 {
-        return ( grHighColors[ widget ] );
+    return ( grHighColors[ widget ] );
 }
 inline QColor* OThemeBase::gradientLow( WidgetType widget ) const
 {
-        return ( grLowColors[ widget ] );
+    return ( grLowColors[ widget ] );
 }
 inline QImage* OThemeBase::image( WidgetType widget ) const
 {
-        return ( images[ widget ] );
+    return ( images[ widget ] );
 }
 inline OThemeBase::SButton OThemeBase::scrollBarLayout() const
 {
-        return ( sbPlacement );
+    return ( sbPlacement );
 }
 inline OThemeBase::ArrowStyle OThemeBase::arrowType() const
 {
-        return ( arrowStyle );
+    return ( arrowStyle );
 }
 inline OThemeBase::ShadeStyle OThemeBase::shade() const
 {
-        return ( shading );
+    return ( shading );
 }
 inline int OThemeBase::frameWidth() const
 {
-        return ( defaultFrame );
+    return ( defaultFrame );
 }
 inline int OThemeBase::buttonXShift() const
 {
-        return ( btnXShift );
+    return ( btnXShift );
 }
 inline int OThemeBase::splitWidth() const
 {
-        return ( splitterWidth );
+    return ( splitterWidth );
 }
 inline int OThemeBase::buttonYShift() const
 {
-        return ( btnYShift );
+    return ( btnYShift );
 }
 inline int OThemeBase::sliderButtonLength() const
 {
-        if ( isPixmap( Slider ) )
+    if ( isPixmap( Slider ) )
-                return ( uncached( Slider ) ->width() );
+        return ( uncached( Slider ) ->width() );
-        else
+    else
-                return ( sliderLen );
+        return ( sliderLen );
 }
 inline bool OThemeBase::roundButton() const
 {
-        return ( roundedButton );
+    return ( roundedButton );
 }
 inline bool OThemeBase::roundComboBox() const
 {
-        return ( roundedCombo );
+    return ( roundedCombo );
 }
 inline bool OThemeBase::roundSlider() const
 {
-        return ( roundedSlider );
+    return ( roundedSlider );
 }
 inline bool OThemeBase::activeTabLine() const
 {
-        return ( aTabLine );
+    return ( aTabLine );
 }
 inline bool OThemeBase::inactiveTabLine() const
 {
-        return ( iTabLine );
+    return ( iTabLine );
 }
 inline int OThemeBase::getSBExtent() const
 {
-        return ( sbExtent );
+    return ( sbExtent );
 }
 inline OThemePixmap* OThemeBase::borderPixmap( WidgetType widget )
 {
-        return ( pbPixmaps[ widget ] );
+    return ( pbPixmaps[ widget ] );
 }
 #endif