All of the files in this commit have an inheritance member function

mismatch correction. None are serious, but all would have been improperly mislinked in the inheritance hierarchy if attempted to be used.
author: erik <erik> 2007-01-10 17:24:23 (UTC)
committer: erik <erik> 2007-01-10 17:24:23 (UTC)
commit: e7d3e1d0f3c75979c01ea6373ed3c80d0c986000 (patch) (unidiff)
tree: 34a6e8aa3de82f07c0531e59f375da216fbfb97a
parent: 51bd5e8d542372ad54898ce642fe9b82b8ba83f3 (diff)
download: opie-e7d3e1d0f3c75979c01ea6373ed3c80d0c986000.zip
opie-e7d3e1d0f3c75979c01ea6373ed3c80d0c986000.tar.gz
opie-e7d3e1d0f3c75979c01ea6373ed3c80d0c986000.tar.bz2
8 files changed, 14 insertions, 14 deletions
diff --git a/core/pim/datebook/holiday/national/nationalcfg.cpp b/core/pim/datebook/holiday/national/nationalcfg.cpp
index f71c833..33e9db3 100644
--- a/core/pim/datebook/holiday/national/nationalcfg.cpp
+++ b/core/pim/datebook/holiday/national/nationalcfg.cpp
@@ -1,371 +1,371 @@
 #include "nationalcfg.h"
 #include <opie2/odebug.h>
 #include <qfile.h>
 static QString _key_desc="description";
 static QString _key_doc="nationaldays";
 static QString _key_list="entries";
 static QString _key_entry="entry";
 static QString _key_calc="calculation";
 static QString _content_type="type";
 static QString _content_float="floating";
 static QString _content_fix="fix";
 static QString _content_name="name";
 static QString _content_value="value";
 static QString _content_date="date";
 static QString _content_weekd="weekday";
 static QString _content_offset="offset";
 static QString _content_dayofmonth="dayofmonth";
 static QString _content_datedep="datedep";
 static QString _content_month="month";
 NHcfg::NHcfg()
    :QXmlDefaultHandler(),err(""),_path("")
 {
 }
 NHcfg::~NHcfg()
 {
 }
 bool NHcfg::load(const QString&aPath)
 {
    _path=aPath;
    stage = 0;
    QFile *f=new QFile(_path);
    if (!f) {
        oerr << "Could not open file" << oendl;
        return false;
    }
    QXmlInputSource is(*f);
    QXmlSimpleReader reader;
    reader.setContentHandler(this);
    reader.setErrorHandler(this);
    currentFixList.clear();
    currentFloatList.clear();
    counter = 0;
    level = 0;
    err = "";
    bool ret = reader.parse(is);
    if (err.length()>0)
        odebug << "Errors: " << err << oendl;
    return ret;
 }
 const tentrylist&NHcfg::fixDates()const
 {
    return currentFixList;
 }
 const tentrylist&NHcfg::floatingDates()const
 {
    return currentFloatList;
 }
 bool NHcfg::warning(const QXmlParseException& e)
 {
        QString tmp;
        tmp.sprintf("%d: warning: %s\n", e.lineNumber(),
                (const char*) e.message().utf8());
        err += tmp;
        return true;
 }
 bool NHcfg::error(const QXmlParseException& e)
 {
        QString tmp;
        tmp.sprintf("%d: error: %s\n", e.lineNumber(),
                (const char*) e.message().utf8());
        err += tmp;
        return true;
 }
 bool NHcfg::fatalError(const QXmlParseException& e)
 {
        QString tmp;
        tmp.sprintf("%d: fatal error: %s\n", e.lineNumber(),
                (const char*) e.message().utf8());
        err += tmp;
        return false;
 }
 bool NHcfg::startElement(const QString&, const QString&,const QString& name, const QXmlAttributes& attr)
 {
    bool ret = false;
    if (name==_key_doc) {
        stage = 1;
        return true;
    }
    if (stage == 0) {
        err = "This is not a national holiday config file";
        return false;
    }
    if (name==_key_desc) {
        stage = 2;
        ret = setName(attr);
        return ret;
    }
    if (stage<2) {return false;}
    if (name==_key_list) {stage=3;return true;}
    if (stage<3) {return false;}
    if (name==_key_entry) {
        ++level;
        ++counter;
        m_currentEntry = NHentry();
  //      odebug << "Level == " << level << oendl;
    }
    if (name==_key_calc) {
        ++level;
 //        odebug << "Level == " << level << oendl;
        return true;
    }
    if (level == 1) {
        return parsevalue(name,attr);
    } else if (level >= 2) {
        return parseCalc(name,attr);
    }
 }
 bool NHcfg::setName(const QXmlAttributes&attr)
 {
    int nindx = attr.index("value");
    if (nindx==-1) {
        return false;
    }
    _contentname = attr.value(nindx);
    return true;
 }
 bool NHcfg::parsevalue(const QString&name,const QXmlAttributes&attr)
 {
    if (name != _key_entry && name != _key_calc) {err = QString("Not a valid entry (%1)").arg(name); return false;}
    int nindex = attr.index(_content_name);
    int dindex = attr.index(_content_date);
    int tindex = attr.index(_content_type);
    if (nindex == -1) {
        err = QString("Listentry %1 is invalid (name missing)").arg(counter);
        return false;
    }
    m_currentEntry.setName(attr.value(nindex));
    if (tindex != -1 && attr.value(tindex)==_content_float) {
        m_currentEntry.setType(NHentry::floating);
        return true;
    }
    if (dindex == -1) {
        err = QString("Listentry %1 is invalid ").arg(counter);return false;
    }
    QString txt = attr.value(nindex);
    QString dstring = attr.value(dindex);
    QStringList e = QStringList::split("-",dstring);
    if (e.count()!=2){err=QString("Datestring %1 is invalid (entry %2)").arg(dstring).arg(counter);return false;}
    QDate d(0,e[0].toInt(),e[1].toInt());
    m_currentEntry.setDate(d);
    return true;
 }
 bool NHcfg::parseCalc(const QString&name,const QXmlAttributes&attr)
 {
    ++level;
    int vindex = attr.index(_content_value);
    if (vindex == -1) {
        err = QString("Value for element %1 on entry %2 is missing").arg(name).arg(counter);
        return false;
    }
    int what_c =0;
    QString what = name.lower();
    QString value;
    if (what == _content_date) {
        what_c = 1;
    } else if (what == _content_weekd) {
        what_c = 2;
    } else if (what == _content_offset) {
        what_c = 3;
    } else if (what == _content_dayofmonth) {
        what_c = 4;
    } else if (what == _content_datedep) {
        what_c = 5;
    } else if (what == _content_month) {
        what_c = 6;
    }
    if (what_c == 0) {
        err = QString("Unknown element %1 on entry %2").arg(name).arg(counter);
        return false;
    }
    value = attr.value(vindex).lower();
    QStringList e;
    QDate d;
    bool dotformat = false;
    switch (what_c) {
        case 1:
            if (value != "easter") {
                e = QStringList::split("-",value);
                if (e.count()!=2) {
                    e = QStringList::split(".",value);
                    dotformat = true;
                }
                if (e.count()!=2){err=QString("Datestring %1 is invalid (entry %2)").arg(value).arg(counter);return false;}
                if (!dotformat) {
                    d=QDate(0,e[0].toInt(),e[1].toInt());
                } else {
                    d=QDate(0,e[1].toInt(),e[0].toInt());
                }
            } else {
                d=QDate(9999,1,1);
            }
            m_currentEntry.setDate(d);
        break;
        case 2:
            m_currentEntry.setWeekday(value);
        break;
        case 3:
            m_currentEntry.setOffet(value.toInt());
        break;
        case 4:
            m_currentEntry.setDayofmonth(value);
        break;
        case 5:
            m_currentEntry.setDaydep(value);
        break;
        case 6:
            m_currentEntry.setMonth(value);
        break;
    }
    return true;
 }
 bool NHcfg::endElement(const QString&, const QString&,const QString& name)
 {
 //    odebug << "End element: " << name << oendl;
    if (name==_key_entry) {
        if (m_currentEntry.type()==NHentry::fix) {
            currentFixList.append(m_currentEntry);
        } else {
            currentFloatList.append(m_currentEntry);
 //            odebug << "Floatlist count " << currentFloatList.count() << oendl;
        }
    } else if (name==_key_calc) {
    }
    if (stage>=3) {
        --level;
    }
 //    odebug << "Level == " << level << oendl;
    return true;
 }
-const QString&NHcfg::errorString()const
+QString NHcfg::errorString() const
 {
    return err;
 }
 NHentry::NHentry()
    :m_Type(fix)
 {
    m_Offset=0;
 }
 NHentry::~NHentry()
 {}
 void NHentry::setName(const QString&aName)
 {
    m_Name = aName;
 }
 const QString&NHentry::name()const
 {
    return m_Name;
 }
 void NHentry::setType(NHentry::entry_type aType)
 {
    m_Type = aType;
 }
 NHentry::entry_type NHentry::type()const
 {
    return m_Type;
 }
 void NHentry::setDate(const QDate&aDate)
 {
    m_Date = aDate;
 }
 const QDate&NHentry::date()const
 {
    return m_Date;
 }
 void NHentry::setWeekday(const QString&aDay)
 {
    m_Weekday = aDay;
 }
 const QString&NHentry::weekday()const
 {
    return m_Weekday;
 }
 void NHentry::setDayofmonth(const QString&aDay)
 {
    m_Dayofmonth = aDay;
 }
 const QString&NHentry::dayofmonth()const
 {
    return m_Dayofmonth;
 }
 void NHentry::setDaydep(const QString&dep)
 {
    m_Depth = dep;
 }
 const QString&NHentry::daydep()const
 {
    return m_Depth;
 }
 void NHentry::setMonth(const QString&month)
 {
    m_Month = month;
 }
 const QString&NHentry::month()const
 {
    return m_Month;
 }
 void NHentry::setOffet(int aOffset)
 {
    m_Offset = aOffset;
 }
 const int NHentry::offset()const
 {
    return m_Offset;
 }
diff --git a/core/pim/datebook/holiday/national/nationalcfg.h b/core/pim/datebook/holiday/national/nationalcfg.h
index 872df65..2aedd95 100644
--- a/core/pim/datebook/holiday/national/nationalcfg.h
+++ b/core/pim/datebook/holiday/national/nationalcfg.h
@@ -1,75 +1,75 @@
 #ifndef _NATIONAL_CFG_H
 #define _NATIONAL_CFG_H
 #include <qxml.h>
 #include <qstringlist.h>
 #include <qvaluelist.h>
 #include <qmap.h>
 #include <qdatetime.h>
 typedef QMap<QDate,QStringList> tholidaylist;
 class NHentry
 {
 public:
    enum entry_type{fix,floating};
    NHentry();
    virtual ~NHentry();
    void setName(const QString&);
    const QString&name()const;
    void setType(entry_type);
    entry_type type()const;
    void setDate(const QDate&);
    const QDate&date()const;
    void setWeekday(const QString&);
    const QString&weekday()const;
    void setDayofmonth(const QString&);
    const QString&dayofmonth()const;
    void setDaydep(const QString&);
    const QString&daydep()const;
    void setMonth(const QString&);
    const QString&month()const;
    void setOffet(int);
    const int offset()const;
 protected:
    entry_type m_Type;
    QString m_Name,m_Weekday,m_Dayofmonth,m_Depth,m_Month;
    QDate m_Date;
    int m_Offset;
 };
 typedef QValueList<NHentry> tentrylist;
 class NHcfg:public QXmlDefaultHandler
 {
 public:
    NHcfg();
    virtual ~NHcfg();
    bool load(const QString&);
    const tentrylist&fixDates()const;
    const tentrylist&floatingDates()const;
    virtual bool warning(const QXmlParseException& e);
    virtual bool error(const QXmlParseException& e);
    virtual bool fatalError(const QXmlParseException& e);
    virtual bool startElement(const QString&, const QString&,const QString& name, const QXmlAttributes& attr);
    virtual bool endElement(const QString&, const QString&,const QString& name);
-    virtual const QString&errorString()const;
+    virtual QString errorString()const;
 protected:
    QString err,_contentname;
    QString _path;
    NHentry m_currentEntry;
    bool setName(const QXmlAttributes&);
    bool parsevalue(const QString&,const QXmlAttributes&);
    bool parseCalc(const QString&,const QXmlAttributes&);
    int stage,counter,level;
    tentrylist currentFloatList,currentFixList;
 };
 #endif
diff --git a/inputmethods/handwriting/qimpenwidget.cpp b/inputmethods/handwriting/qimpenwidget.cpp
index 8f8f582..7223e1a 100644
--- a/inputmethods/handwriting/qimpenwidget.cpp
+++ b/inputmethods/handwriting/qimpenwidget.cpp
@@ -1,446 +1,446 @@
 /**********************************************************************
 ** 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 <qapplication.h>
 #include <qinputdialog.h>
 #include <qpainter.h>
 #include <qfile.h>
 #include <qdatastream.h>
 #include <qtimer.h>
 #include "qimpenchar.h"
 #include "qimpenwidget.h"
        #define TITLE_WIDTH30  // ### magic
 /*!
  \class QIMPenWidget qimpenwidget.h
  Draws characters and allows input of characters.
 */
 QIMPenWidget::QIMPenWidget( QWidget *parent )
 : QWidget( parent )
 {
    charSets.setAutoDelete( TRUE );
    inputStroke = 0;
    outputChar = 0;
    outputStroke = 0;
    mode = Waiting;
    currCharSet = 0;
    readOnly = FALSE;
    strokes.setAutoDelete( TRUE );
    timer = new QTimer(this);
    connect( timer, SIGNAL(timeout()), SLOT(timeout()));
    setBackgroundColor( qApp->palette().color( QPalette::Active,
                                               QColorGroup::Base ) );
    strokeColor = black;
    setFixedHeight( 75 );
 }
 void QIMPenWidget::clear()
 {
    timer->stop();
    mode = Waiting;
    QRect r( dirtyRect );
    QIMPenStrokeIterator it( strokes );
    while ( it.current() ) {
        r |= it.current()->boundingRect();
        ++it;
    }
    outputChar = 0;
    outputStroke = 0;
    strokes.clear();
    if ( !r.isNull() ) {
        r.moveBy( -2, -2 );
        r.setSize( r.size() + QSize( 4, 4 ) );
        repaint( r );
    } else {
        repaint();
    }
 }
 void QIMPenWidget::removeStroke()
 {
    QRect r( dirtyRect );
    QIMPenStroke *st = strokes.getFirst();
    QRect strokeRect;
    if ( st )
       strokeRect = st->boundingRect();
    r |= strokeRect;
    strokes.removeFirst();
    if ( !r.isNull() ) {
        r.moveBy( -2, -2 );
        r.setSize( r.size() + QSize( 4, 4 ) );
        repaint( r );
    }
 }
 void QIMPenWidget::greyStroke()
 {
    QRect r( dirtyRect );
    QIMPenStroke *st = strokes.getLast();
    QRect strokeRect;
    if ( st )
       strokeRect = st->boundingRect();
    r |= strokeRect;
    QColor oldCol = strokeColor;
    strokeColor = gray;
    if ( !r.isNull() ) {
        r.moveBy( -2, -2 );
        r.setSize( r.size() + QSize( 4, 4 ) );
        repaint( r );
    }
    strokeColor = oldCol;
 }
 /*!
  Insert a character set into the list.
 */
 void QIMPenWidget::insertCharSet( QIMPenCharSet *cs, int stretch, int pos )
 {
    CharSetEntry *e = new CharSetEntry;
    e->cs = cs;
    e->stretch = stretch;
    if ( pos < 0 )
        pos = charSets.count();
    charSets.insert( pos, e );
    currCharSet = 0;
    emit changeCharSet( currCharSet );
    emit changeCharSet( charSets.at(currCharSet)->cs );
    totalStretch = 0;
    CharSetEntryIterator it( charSets );
    for ( ; it.current(); ++it )
        totalStretch += it.current()->stretch;
    update();
 }
 /*!
  Remove a character set from the list.
 */
 void QIMPenWidget::removeCharSet( int pos )
 {
    if ( pos >= 0 && pos < (int)charSets.count() ) {
        charSets.remove( pos );
        currCharSet = 0;
        if ( charSets.count() ) {
            emit changeCharSet( currCharSet );
            emit changeCharSet( charSets.at(currCharSet)->cs );
        }
        totalStretch = 0;
        CharSetEntryIterator it( charSets );
        for ( ; it.current(); ++it )
            totalStretch += it.current()->stretch;
        update();
    }
 }
 void QIMPenWidget::changeCharSet( QIMPenCharSet *cs, int pos )
 {
    if ( pos >= 0 && pos < (int)charSets.count() ) {
        CharSetEntry *e = new CharSetEntry;
        e->cs = cs;
        e->stretch = charSets.at(pos)->stretch;
        charSets.remove( pos );
        charSets.insert( pos, e );
        if ( pos == currCharSet ) {
            emit changeCharSet( charSets.at(currCharSet)->cs );
        }
        update();
    }
 }
 void QIMPenWidget::clearCharSets()
 {
    charSets.clear();
    currCharSet = 0;
    update();
 }
 /*!
  Display a character. \a speed determines how quickly the character is
  drawn.
 */
 void QIMPenWidget::showCharacter( QIMPenChar *ch, int speed )
 {
    outputChar = 0;
    outputStroke = 0;
    strokes.clear();
    mode = Output;
    repaint();
    if ( !ch || ch->isEmpty() ) {
        mode = Waiting;
        return;
    }
    outputChar = ch;
    outputStroke = outputChar->penStrokes().getFirst();
    if ( speed < 0 ) speed = 0;
    if ( speed > 20 ) speed = 20;
    speed = 50 - speed;
    pointIndex = 0;
    strokeIndex = 0;
    lastPoint = outputStroke->startingPoint();
    QRect br( outputChar->boundingRect() );
    lastPoint.setX( (width() - br.width()) / 2 + (lastPoint.x () - br.left()) );
    QPoint offset = lastPoint - outputStroke->startingPoint();
    br.moveBy( offset.x(), offset.y() );
    dirtyRect |= br;
    timer->start( speed );
 }
 /*!
  Handle drawing/clearing of characters.
 */
 void QIMPenWidget::timeout()
 {
    if ( mode == Output ) {
        const QArray<QIMPenGlyphLink> &chain = outputStroke->chain();
        if ( pointIndex < chain.count() ) {
            QPainter paint( this );
            paint.setBrush( Qt::black );
            for ( unsigned i = 0; i < 3 && pointIndex < chain.count(); i++ ) {
                lastPoint.rx() += chain[pointIndex].dx;
                lastPoint.ry() += chain[pointIndex].dy;
                pointIndex++;
                paint.drawRect( lastPoint.x()-1, lastPoint.y()-1, 2, 2 );
            }
        }
        if ( pointIndex >= chain.count() ) {
            QIMPenStrokeList strokes = outputChar->penStrokes();
            if ( strokeIndex < (int)strokes.count() - 1 ) {
                pointIndex = 0;
                strokeIndex++;
                outputStroke = strokes.at( strokeIndex );
                lastPoint = outputChar->startingPoint();
                QRect br( outputChar->boundingRect() );
                lastPoint.setX( (width() - br.width()) / 2
                                + (lastPoint.x () - br.left()) );
                QPoint off = lastPoint - outputChar->startingPoint();
                lastPoint = outputStroke->startingPoint() + off;
            } else {
                timer->stop();
                mode = Waiting;
            }
        }
    } else if ( mode == Waiting ) {
        QRect r( dirtyRect );
        if ( !r.isNull() ) {
            r.moveBy( -2, -2 );
            r.setSize( r.size() + QSize( 4, 4 ) );
            repaint( r );
        }
    }
 }
 /*!
  If the point \a p is over one of the character set titles, switch
  to the set and return TRUE.
 */
 bool QIMPenWidget::selectSet( QPoint p )
 {
    if ( charSets.count() ) {
        CharSetEntryIterator it( charSets );
        int spos = 0;
        int idx = 0;
        for ( ; it.current(); ++it, idx++ ) {
            int setWidth = width() * it.current()->stretch / totalStretch;
            spos += setWidth;
            if ( p.x() < spos ) {
                if ( idx != currCharSet ) {
                    currCharSet = idx;
                    update( 0, 0, width(), 12 );
                    emit changeCharSet( currCharSet );
                    emit changeCharSet( charSets.at(currCharSet)->cs );
                }
                break;
            }
        }
    }
    return FALSE;
 }
 /*!
  Hopefully returns a sensible size.
 */
-QSize QIMPenWidget::sizeHint()
+QSize QIMPenWidget::sizeHint() const
 {
    return QSize( TITLE_WIDTH * charSets.count(), 75 );
 }
 void QIMPenWidget::mousePressEvent( QMouseEvent *e )
 {
    if ( !readOnly && e->button() == LeftButton && mode == Waiting ) {
        // if selectSet returns false the click was not over the
        // char set selectors.
        if ( !selectSet( e->pos() ) ) {
            // start of character input
            timer->stop();
            if ( outputChar ) {
                outputChar = 0;
                outputStroke = 0;
                repaint();
            }
            mode = Input;
            lastPoint = e->pos();
            emit beginStroke();
            inputStroke = new QIMPenStroke;
            strokes.append( inputStroke );
            inputStroke->beginInput( e->pos() );
            QPainter paint( this );
            paint.setBrush( Qt::black );
            paint.drawRect( lastPoint.x()-1, lastPoint.y()-1, 2, 2 );
        }
    }
 }
 void QIMPenWidget::mouseReleaseEvent( QMouseEvent *e )
 {
    if ( !readOnly && e->button() == LeftButton && mode == Input ) {
        mode = Waiting;
        inputStroke->endInput();
        if ( charSets.count() )
            emit stroke( inputStroke );
        inputStroke = 0;
    }
 }
 void QIMPenWidget::mouseMoveEvent( QMouseEvent *e )
 {
    if ( !readOnly && mode == Input ) {
        int dx = QABS( e->pos().x() - lastPoint.x() );
        int dy = QABS( e->pos().y() - lastPoint.y() );
        if ( dx + dy > 1 ) {
            if ( inputStroke->addPoint( e->pos() ) ) {
                QPainter paint( this );
                paint.setPen( Qt::black );
                paint.setBrush( Qt::black );
                const QArray<QIMPenGlyphLink> &chain = inputStroke->chain();
                QPoint p( e->pos() );
                for ( int i = (int)chain.count()-1; i >= 0; i-- ) {
                    paint.drawRect( p.x()-1, p.y()-1, 2, 2 );
                    p.rx() -= chain[i].dx;
                    p.ry() -= chain[i].dy;
                    if ( p == lastPoint )
                        break;
                }
                /* ### use this when thick lines work properly on all devices
                paint.setPen( QPen( Qt::black, 2 ) );
                paint.drawLine( lastPoint, e->pos() );
                */
            }
            lastPoint = e->pos();
        }
    }
 }
 void QIMPenWidget::paintEvent( QPaintEvent * )
 {
    QPainter paint( this );
    // draw guidelines
    paint.setPen( Qt::gray );
    paint.drawLine( 0, 0, width(), 0 );
    int y = height() / 3;
    paint.drawLine( 0, y, width(), y );
    y *= 2;
    paint.setPen( blue );
    paint.drawLine( 0, y, width(), y );
    paint.setPen( Qt::gray );
    if ( !charSets.count() )
        return;
    // draw the character set titles
    QFont selFont( "helvetica", 8, QFont::Bold );
    QFont font( "helvetica", 8 );
    CharSetEntryIterator it( charSets );
    int spos = 0;
    for ( ; it.current(); ++it ) {
        int setWidth = width() * it.current()->stretch / totalStretch;
        spos += setWidth;
        if ( it.current() != charSets.getLast() ) {
            paint.drawLine( spos, 0, spos, 5 );
            paint.drawLine( spos, height()-1, spos, height()-6 );
        }
        paint.setFont( font );
        int w = paint.fontMetrics().width( it.current()->cs->title() );
        int tpos = spos - setWidth / 2;
        paint.drawText( tpos - w/2, 0, w, 12, QPainter::AlignCenter,
                        it.current()->cs->title() );
    }
    // draw any character that should be displayed when repainted.
    QPoint off;
    const QIMPenStrokeList *stk = 0;
    if ( outputChar && mode == Waiting ) {
        stk = &outputChar->penStrokes();
        QPoint p( outputChar->startingPoint() );
        QRect br( outputChar->boundingRect() );
        p.setX( (width() - br.width()) / 2 + (p.x () - br.left()) );
        off = p - outputChar->startingPoint();
    } else if ( mode == Waiting ) {
        stk = &strokes;
        strokeColor = gray;
    }
    if ( stk && !stk->isEmpty() ) {
        paint.setPen( strokeColor );
        paint.setBrush( strokeColor );
        QIMPenStrokeIterator it( *stk );
        while ( it.current() ) {
            QPoint p = it.current()->startingPoint() + off;
            paint.drawRect( p.x()-1, p.y()-1, 2, 2 );
            const QArray<QIMPenGlyphLink> &chain = it.current()->chain();
            for ( unsigned i = 0; i < chain.count(); i++ ) {
                    p.rx() += chain[i].dx;
                    p.ry() += chain[i].dy;
                    paint.drawRect( p.x()-1, p.y()-1, 2, 2 );
            }
            ++it;
            if ( it.atLast() && mode == Waiting )
                strokeColor = black;
        }
    }
    dirtyRect = QRect();
    // debug
 /*
    if ( input ) {
        QArray<int> sig = input->sig();
        for ( unsigned i = 0; i < sig.count(); i++ ) {
            paint.drawPoint( 200 + i, height()/2 - sig[i] / 8 );
        }
    }
 */
 }
 void QIMPenWidget::resizeEvent( QResizeEvent *e )
 {
    if ( mode == Output )
        showCharacter( outputChar, 0 );
    QWidget::resizeEvent( e );
 }
diff --git a/inputmethods/handwriting/qimpenwidget.h b/inputmethods/handwriting/qimpenwidget.h
index 98d7f5c..d156554 100644
--- a/inputmethods/handwriting/qimpenwidget.h
+++ b/inputmethods/handwriting/qimpenwidget.h
@@ -1,88 +1,88 @@
 /**********************************************************************
 ** 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 <qwidget.h>
 #include <qlist.h>
 #include "qimpenchar.h"
 class QIMPenWidget : public QWidget
 {
    Q_OBJECT
 public:
    QIMPenWidget( QWidget *parent );
    void clear();
    void greyStroke();
    void setReadOnly( bool r ) { readOnly = r; }
    void insertCharSet( QIMPenCharSet *cs, int stretch=1, int pos=-1 );
    void removeCharSet( int );
    void changeCharSet( QIMPenCharSet *cs, int pos );
    void clearCharSets();
    void showCharacter( QIMPenChar *, int speed = 10 );
-    virtual QSize sizeHint();
+    virtual QSize sizeHint() const;
 public slots:
    void removeStroke();
 signals:
    void changeCharSet( QIMPenCharSet *cs );
    void changeCharSet( int );
    void beginStroke();
    void stroke( QIMPenStroke *ch );
 protected slots:
    void timeout();
 protected:
    enum Mode { Waiting, Input, Output };
    bool selectSet( QPoint );
    virtual void mousePressEvent( QMouseEvent *e );
    virtual void mouseReleaseEvent( QMouseEvent *e );
    virtual void mouseMoveEvent( QMouseEvent *e );
    virtual void paintEvent( QPaintEvent *e );
    virtual void resizeEvent( QResizeEvent *e );
    struct CharSetEntry {
        QIMPenCharSet *cs;
        int stretch;
    };
    typedef QList<CharSetEntry> CharSetEntryList;
    typedef QListIterator<CharSetEntry> CharSetEntryIterator;
 protected:
    Mode mode;
    bool autoHide;
    bool readOnly;
    QPoint lastPoint;
    unsigned pointIndex;
    int strokeIndex;
    int currCharSet;
    QTimer *timer;
    QColor strokeColor;
    QRect dirtyRect;
    QIMPenChar *outputChar;
    QIMPenStroke *outputStroke;
    QIMPenStroke *inputStroke;
    QIMPenStrokeList strokes;
    CharSetEntryList charSets;
    int totalStretch;
 };
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp b/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp
index 55e47e2..2ebccd2 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp
@@ -1,664 +1,664 @@
 /*
                             This file is part of the Opie Project
                             Copyright (C) Stefan Eilers (Eilers.Stefan@epost.de)
              =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
            .=l.
           .>+-=
 _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
 - .   .-<_>     .<>         Foundation; either version 2 of the License,
     ._= =}       :          or (at your option) any later version.
    .%`+i>       _;_.
    .i_,=:_.      -<s.       This program is distributed in the hope that
     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
    : ..    .:,     . . .    without even the implied warranty of
    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
 :     =  ...= . :.=-
 -.   .:....=;==+<;          You should have received a copy of the GNU
  -_. . .   )=.  =           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.
 */
 /* OPIE */
 #include <opie2/opimnotifymanager.h>
 #include <opie2/opimrecurrence.h>
 #include <opie2/opimtimezone.h>
 #include <opie2/odatebookaccessbackend_xml.h>
 #include <opie2/odebug.h>
 #include <qtopia/global.h>
 #include <qtopia/stringutil.h>
 #include <qtopia/timeconversion.h>
 /* QT */
 #include <qasciidict.h>
 #include <qfile.h>
 /* STD */
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 using namespace Opie;
 namespace {
    // FROM TT again
 char *strstrlen(const char *haystack, int hLen, const char* needle, int nLen)
 {
    char needleChar;
    char haystackChar;
    if (!needle || !haystack || !hLen || !nLen)
    return 0;
    const char* hsearch = haystack;
    if ((needleChar = *needle++) != 0) {
    nLen--; //(to make up for needle++)
    do {
        do {
        if ((haystackChar = *hsearch++) == 0)
            return (0);
        if (hsearch >= haystack + hLen)
            return (0);
        } while (haystackChar != needleChar);
    } while (strncmp(hsearch, needle, QMIN(hLen - (hsearch - haystack), nLen)) != 0);
    hsearch--;
    }
    return ((char *)hsearch);
 }
 }
 namespace {
    time_t start, end, created, rp_end;
    OPimRecurrence* rec;
    static OPimRecurrence* recur() {
        if (!rec)
            rec = new OPimRecurrence;
        return rec;
    }
    int alarmTime;
    int snd;
    enum Attribute{
        FDescription = 0,
        FLocation,
        FCategories,
        FUid,
        FType,
        FAlarm,
        FSound,
        FRType,
        FRWeekdays,
        FRPosition,
        FRFreq,
        FRHasEndDate,
        FREndDate,
        FRStart,
        FREnd,
        FNote,
        FCreated,      // Should't this be called FRCreated ?
        FTimeZone,
        FRecParent,
        FRecChildren,
        FExceptions
    };
    // FIXME: Use OPimEvent::toMap() here !! (eilers)
    static void save( const OPimEvent& ev, QString& buf ) {
        buf += " description=\"" + Qtopia::escapeString(ev.description() ) + "\"";
        if (!ev.location().isEmpty() )
            buf += " location=\"" + Qtopia::escapeString(ev.location() ) + "\"";
        if (!ev.categories().isEmpty() )
            buf += " categories=\""+ Qtopia::escapeString( Qtopia::Record::idsToString( ev.categories() ) ) + "\"";
        buf += " uid=\"" + QString::number( ev.uid() ) + "\"";
        if (ev.isAllDay() )
            buf += " type=\"AllDay\""; // is that all ?? (eilers)
        if (ev.hasNotifiers() ) {
            OPimAlarm alarm = ev.notifiers().alarms()[0]; // take only the first
            int minutes = alarm.dateTime().secsTo( ev.startDateTime() ) / 60;
            buf += " alarm=\"" + QString::number(minutes) + "\" sound=\"";
            if ( alarm.sound() == OPimAlarm::Loud )
                buf += "loud";
            else
                buf += "silent";
            buf += "\"";
        }
        if ( ev.hasRecurrence() ) {
            buf += ev.recurrence().toString();
        }
        /*
         * fscking timezones :) well, we'll first convert
         * the QDateTime to a QDateTime in UTC time
         * and then we'll create a nice time_t
         */
        OPimTimeZone zone( (ev.timeZone().isEmpty()||ev.isAllDay()) ? OPimTimeZone::utc() : OPimTimeZone::current() );
        buf += " start=\"" + QString::number( zone.fromDateTime( ev.startDateTime()))  + "\"";
        buf += " end=\""   + QString::number( zone.fromDateTime( ev.endDateTime()  ))  + "\"";
        if (!ev.note().isEmpty() ) {
            buf += " note=\"" + Qtopia::escapeString( ev.note() ) + "\"";
        }
        /*
         * Don't save a timezone if AllDay Events
         * as they're UTC only anyway
         */
        if (!ev.isAllDay() ) {
            buf += " timezone=\"";
            if ( ev.timeZone().isEmpty() )
                buf += "None";
            else
                buf += ev.timeZone();
            buf += "\"";
        }
        if (ev.parent() != 0 ) {
            buf += " recparent=\""+QString::number(ev.parent() )+"\"";
        }
        if (ev.children().count() != 0 ) {
            QArray<int> children = ev.children();
            buf += " recchildren=\"";
            for ( uint i = 0; i < children.count(); i++ ) {
                if ( i != 0 ) buf += " ";
                buf += QString::number( children[i] );
            }
            buf+= "\"";
        }
        // skip custom writing
    }
    static bool saveEachEvent( const QMap<int, OPimEvent>& list, QFile& file ) {
        QMap<int, OPimEvent>::ConstIterator it;
        QString buf;
        QCString str;
        int total_written;
        for ( it = list.begin(); it != list.end(); ++it ) {
            buf = "<event";
            save( it.data(), buf );
            buf += " />\n";
            str = buf.utf8();
            total_written = file.writeBlock(str.data(), str.length() );
            if ( total_written != int(str.length() ) )
                return false;
        }
        return true;
    }
 }
 namespace Opie {
 ODateBookAccessBackend_XML::ODateBookAccessBackend_XML( const QString& ,
                                                        const QString& fileName )
    : ODateBookAccessBackend() {
    m_name = fileName.isEmpty() ? Global::applicationFileName( "datebook", "datebook.xml" ) : fileName;
    m_changed = false;
 }
 ODateBookAccessBackend_XML::~ODateBookAccessBackend_XML() {
 }
 bool ODateBookAccessBackend_XML::load() {
    return loadFile();
 }
 bool ODateBookAccessBackend_XML::reload() {
    clear();
    return load();
 }
 bool ODateBookAccessBackend_XML::save() {
    if (!m_changed) return true;
    int total_written;
    QString strFileNew = m_name + ".new";
    QFile f( strFileNew );
    if (!f.open( IO_WriteOnly | IO_Raw ) ) return false;
    QString buf( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
    buf += "<!DOCTYPE DATEBOOK><DATEBOOK>\n";
    buf += "<events>\n";
    QCString str = buf.utf8();
    total_written = f.writeBlock( str.data(), str.length() );
    if ( total_written != int(str.length() ) ) {
        f.close();
        QFile::remove( strFileNew );
        return false;
    }
    if (!saveEachEvent( m_raw, f ) ) {
        f.close();
        QFile::remove( strFileNew );
        return false;
    }
    if (!saveEachEvent( m_rep, f ) ) {
        f.close();
        QFile::remove( strFileNew );
        return false;
    }
    buf = "</events>\n</DATEBOOK>\n";
    str = buf.utf8();
    total_written = f.writeBlock( str.data(), str.length() );
    if ( total_written != int(str.length() ) ) {
        f.close();
        QFile::remove( strFileNew );
        return false;
    }
    f.close();
    if ( ::rename( strFileNew, m_name ) < 0 ) {
        QFile::remove( strFileNew );
        return false;
    }
    m_changed = false;
    return true;
 }
 QArray<int> ODateBookAccessBackend_XML::allRecords()const {
    QArray<int> ints( m_raw.count()+ m_rep.count() );
    uint i = 0;
    QMap<int, OPimEvent>::ConstIterator it;
    for ( it = m_raw.begin(); it != m_raw.end(); ++it ) {
        ints[i] = it.key();
        i++;
    }
    for ( it = m_rep.begin(); it != m_rep.end(); ++it ) {
        ints[i] = it.key();
        i++;
    }
    return ints;
 }
-QArray<int> ODateBookAccessBackend_XML::queryByExample(const OPimEvent&, int,  const QDateTime& ) {
+QArray<int> ODateBookAccessBackend_XML::queryByExample(const OPimEvent&, int,  const QDateTime& ) const {
    return QArray<int>();
 }
 void ODateBookAccessBackend_XML::clear() {
    m_changed = true;
    m_raw.clear();
    m_rep.clear();
 }
 OPimEvent ODateBookAccessBackend_XML::find( int uid ) const{
    if ( m_raw.contains( uid ) )
        return m_raw[uid];
    else
        return m_rep[uid];
 }
 bool ODateBookAccessBackend_XML::add( const OPimEvent& ev ) {
    m_changed = true;
    if (ev.hasRecurrence() )
        m_rep.insert( ev.uid(), ev );
    else
        m_raw.insert( ev.uid(), ev );
    return true;
 }
 bool ODateBookAccessBackend_XML::remove( int uid ) {
    m_changed = true;
    m_raw.remove( uid );
    m_rep.remove( uid );
    return true;
 }
 bool ODateBookAccessBackend_XML::replace( const OPimEvent& ev ) {
    replace( ev.uid() ); // ??? Shouldn't this be "remove( ev.uid() ) ??? (eilers)
    return add( ev );
 }
 QArray<int> ODateBookAccessBackend_XML::rawRepeats()const {
    QArray<int> ints( m_rep.count() );
    uint i = 0;
    QMap<int, OPimEvent>::ConstIterator it;
    for ( it = m_rep.begin(); it != m_rep.end(); ++it ) {
        ints[i] = it.key();
        i++;
    }
    return ints;
 }
 QArray<int> ODateBookAccessBackend_XML::nonRepeats()const {
    QArray<int> ints( m_raw.count() );
    uint i = 0;
    QMap<int, OPimEvent>::ConstIterator it;
    for ( it = m_raw.begin(); it != m_raw.end(); ++it ) {
        ints[i] = it.key();
        i++;
    }
    return ints;
 }
 OPimEvent::ValueList ODateBookAccessBackend_XML::directNonRepeats()const {
    OPimEvent::ValueList list;
    QMap<int, OPimEvent>::ConstIterator it;
    for (it = m_raw.begin(); it != m_raw.end(); ++it )
        list.append( it.data() );
    return list;
 }
 OPimEvent::ValueList ODateBookAccessBackend_XML::directRawRepeats()const {
    OPimEvent::ValueList list;
    QMap<int, OPimEvent>::ConstIterator it;
    for (it = m_rep.begin(); it != m_rep.end(); ++it )
        list.append( it.data() );
    return list;
 }
 // FIXME: Use OPimEvent::fromMap() (eilers)
 bool ODateBookAccessBackend_XML::loadFile() {
    m_changed = false;
    int fd = ::open( QFile::encodeName(m_name).data(), O_RDONLY );
    if ( fd < 0 ) return false;
    struct stat attribute;
    if ( ::fstat(fd, &attribute ) == -1 ) {
        ::close( fd );
        return false;
    }
    void* map_addr = ::mmap(NULL, attribute.st_size, PROT_READ, MAP_SHARED, fd, 0 );
    if ( map_addr == ( (caddr_t)-1) ) {
        ::close( fd );
        return false;
    }
    ::madvise( map_addr, attribute.st_size, MADV_SEQUENTIAL );
    ::close( fd );
    QAsciiDict<int> dict(FExceptions+1);
    dict.setAutoDelete( true );
    dict.insert( "description", new int(FDescription) );
    dict.insert( "location", new int(FLocation) );
    dict.insert( "categories", new int(FCategories) );
    dict.insert( "uid", new int(FUid) );
    dict.insert( "type", new int(FType) );
    dict.insert( "alarm", new int(FAlarm) );
    dict.insert( "sound", new int(FSound) );
    dict.insert( "rtype", new int(FRType) );
    dict.insert( "rweekdays", new int(FRWeekdays) );
    dict.insert( "rposition", new int(FRPosition) );
    dict.insert( "rfreq", new int(FRFreq) );
    dict.insert( "rhasenddate", new int(FRHasEndDate) );
    dict.insert( "enddt", new int(FREndDate) );
    dict.insert( "start", new int(FRStart) );
    dict.insert( "end", new int(FREnd) );
    dict.insert( "note", new int(FNote) );
    dict.insert( "created", new int(FCreated) );  // Shouldn't this be FRCreated ??
    dict.insert( "recparent", new int(FRecParent) );
    dict.insert( "recchildren", new int(FRecChildren) );
    dict.insert( "exceptions", new int(FExceptions) );
    dict.insert( "timezone", new int(FTimeZone) );
    // initialiaze db hack
    m_noTimeZone = true;
    char* dt = (char*)map_addr;
    int len = attribute.st_size;
    int i = 0;
    char* point;
    const char* collectionString = "<event ";
    int strLen = ::strlen(collectionString);
    int *find;
    while ( (  point = ::strstrlen( dt+i, len -i, collectionString, strLen ) ) != 0  ) {
        i = point -dt;
        i+= strLen;
        alarmTime = -1;
        snd = 0; // silent
        OPimEvent ev;
        rec = 0;
        while ( TRUE ) {
            while ( i < len && (dt[i] == ' ' || dt[i] == '\n' || dt[i] == '\r') )
        ++i;
        if ( i >= len-2 || (dt[i] == '/' && dt[i+1] == '>') )
        break;
        // we have another attribute, read it.
        int j = i;
        while ( j < len && dt[j] != '=' )
        ++j;
        QCString attr( dt+i, j-i+1);
        i = ++j; // skip =
        // find the start of quotes
        while ( i < len && dt[i] != '"' )
        ++i;
        j = ++i;
        bool haveUtf = FALSE;
        bool haveEnt = FALSE;
        while ( j < len && dt[j] != '"' ) {
        if ( ((unsigned char)dt[j]) > 0x7f )
            haveUtf = TRUE;
        if ( dt[j] == '&' )
            haveEnt = TRUE;
        ++j;
        }
        if ( i == j ) {
        // empty value
        i = j + 1;
        continue;
        }
        QCString value( dt+i, j-i+1 );
        i = j + 1;
        QString str = (haveUtf ? QString::fromUtf8( value )
            : QString::fromLatin1( value ) );
        if ( haveEnt )
        str = Qtopia::plainString( str );
            /*
             * add key + value
             */
            find = dict[attr.data()];
            if (!find)
                ev.setCustomField( attr, str );
            else {
                setField( ev, *find, str );
            }
        }
        /* time to finalize */
        finalizeRecord( ev );
        delete rec;
        m_noTimeZone = true;
    }
    ::munmap(map_addr, attribute.st_size );
    m_changed = false; // changed during add
    return true;
 }
 // FIXME: Use OPimEvent::fromMap() which makes this obsolete.. (eilers)
 void ODateBookAccessBackend_XML::finalizeRecord( OPimEvent& ev ) {
    /*
     * quirk to import datebook files. They normally don't have a
     * timeZone attribute and we treat this as to use OPimTimeZone::current()
     */
    if (m_noTimeZone )
        ev.setTimeZone( OPimTimeZone::current().timeZone() );
    /* AllDay is alway in UTC */
    if ( ev.isAllDay() ) {
        OPimTimeZone utc = OPimTimeZone::utc();
        ev.setStartDateTime( utc.toDateTime( start ) );
        ev.setEndDateTime  ( utc.toDateTime( end   ) );
    }else {
        /* to current date time */
        OPimTimeZone   to_zone( ev.timeZone().isEmpty() ? OPimTimeZone::utc() : OPimTimeZone::current() );
        ev.setStartDateTime(to_zone.toDateTime( start));
        ev.setEndDateTime  (to_zone.toDateTime( end));
    }
    if ( rec && rec->doesRecur() ) {
        OPimTimeZone utc = OPimTimeZone::utc();
        OPimRecurrence recu( *rec ); // call copy c'tor;
        recu.setEndDate ( utc.toDateTime( rp_end ).date() );
        recu.setCreatedDateTime( utc.toDateTime( created ) );
        recu.setStart( ev.startDateTime().date() );
        ev.setRecurrence( recu );
    }
    if (alarmTime != -1 ) {
        QDateTime dt = ev.startDateTime().addSecs( -1*alarmTime*60 );
        OPimAlarm al( snd ,  dt  );
        ev.notifiers().add( al );
    }
    if ( m_raw.contains( ev.uid() ) || m_rep.contains( ev.uid() ) ) {
        ev.setUid( 1 );
    }
    if ( ev.hasRecurrence() )
        m_rep.insert( ev.uid(), ev );
    else
        m_raw.insert( ev.uid(), ev );
 }
 void ODateBookAccessBackend_XML::setField( OPimEvent& e, int id, const QString& value) {
    switch( id ) {
    case FDescription:
        e.setDescription( value );
        break;
    case FLocation:
        e.setLocation( value );
        break;
    case FCategories:
        e.setCategories( e.idsFromString( value ) );
        break;
    case FUid:
        e.setUid( value.toInt() );
        break;
    case FType:
        if ( value == "AllDay" ) {
            e.setAllDay( true );
        }
        break;
    case FAlarm:
        alarmTime = value.toInt();
        break;
    case FSound:
        snd = value == "loud" ? OPimAlarm::Loud : OPimAlarm::Silent;
        break;
        // recurrence stuff
    case FRType:
        if ( value == "Daily" )
            recur()->setType( OPimRecurrence::Daily );
        else if ( value == "Weekly" )
            recur()->setType( OPimRecurrence::Weekly);
        else if ( value == "MonthlyDay" )
            recur()->setType( OPimRecurrence::MonthlyDay );
        else if ( value == "MonthlyDate" )
            recur()->setType( OPimRecurrence::MonthlyDate );
        else if ( value == "Yearly" )
            recur()->setType( OPimRecurrence::Yearly );
        else
            recur()->setType( OPimRecurrence::NoRepeat );
        break;
    case FRWeekdays:
        recur()->setDays( value.toInt() );
        break;
    case FRPosition:
        recur()->setPosition( value.toInt() );
        break;
    case FRFreq:
        recur()->setFrequency( value.toInt() );
        break;
    case FRHasEndDate:
        recur()->setHasEndDate( value.toInt() );
        break;
    case FREndDate: {
        rp_end = (time_t) value.toLong();
        break;
    }
    case FRStart: {
        start =  (time_t) value.toLong();
        break;
    }
    case FREnd: {
        end = ( (time_t) value.toLong() );
        break;
    }
    case FNote:
        e.setNote( value );
        break;
    case FCreated:
        created = value.toInt();
        break;
    case FRecParent:
        e.setParent( value.toInt() );
        break;
    case FRecChildren:{
        QStringList list = QStringList::split(' ', value );
        for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
            e.addChild( (*it).toInt() );
        }
    }
        break;
    case FExceptions:{
        QStringList list = QStringList::split(' ', value );
        for (QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
            QDate date( (*it).left(4).toInt(), (*it).mid(4, 2).toInt(), (*it).right(2).toInt() );
            recur()->exceptions().append( date );
        }
    }
        break;
    case FTimeZone:
        m_noTimeZone = false;
        if ( value != "None" )
            e.setTimeZone( value );
        break;
    default:
        break;
    }
 }
 QArray<int> ODateBookAccessBackend_XML::matchRegexp(  const QRegExp &r ) const
 {
    QArray<int> m_currentQuery( m_raw.count()+ m_rep.count() );
    uint arraycounter = 0;
    QMap<int, OPimEvent>::ConstIterator it;
    for ( it = m_raw.begin(); it != m_raw.end(); ++it )
        if ( it.data().match( r ) )
            m_currentQuery[arraycounter++] = it.data().uid();
    for ( it = m_rep.begin(); it != m_rep.end(); ++it )
        if ( it.data().match( r ) )
            m_currentQuery[arraycounter++] = it.data().uid();
    // Shrink to fit..
    m_currentQuery.resize(arraycounter);
    return m_currentQuery;
 }
 }
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_xml.h b/libopie2/opiepim/backend/odatebookaccessbackend_xml.h
index cb19f76..7369c07 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_xml.h
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_xml.h
@@ -1,88 +1,88 @@
 /*
                             This file is part of the Opie Project
                             Copyright (C) Stefan Eilers (Eilers.Stefan@epost.de)
              =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
            .=l.
           .>+-=
 _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
 - .   .-<_>     .<>         Foundation; either version 2 of the License,
     ._= =}       :          or (at your option) any later version.
    .%`+i>       _;_.
    .i_,=:_.      -<s.       This program is distributed in the hope that
     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
    : ..    .:,     . . .    without even the implied warranty of
    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
 :     =  ...= . :.=-
 -.   .:....=;==+<;          You should have received a copy of the GNU
  -_. . .   )=.  =           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 OPIE_DATE_BOOK_ACCESS_BACKEND_XML__H
 #define OPIE_DATE_BOOK_ACCESS_BACKEND_XML__H
 #include <qmap.h>
 #include <opie2/odatebookaccessbackend.h>
 namespace Opie {
 /**
 * This is the default XML implementation for DateBoook XML storage
 * It fully implements the interface
 * @see ODateBookAccessBackend
 * @see OPimAccessBackend
 */
 class ODateBookAccessBackend_XML : public ODateBookAccessBackend {
 public:
    ODateBookAccessBackend_XML( const QString& appName,
                                const QString& fileName = QString::null);
    ~ODateBookAccessBackend_XML();
    bool load();
    bool reload();
    bool save();
    QArray<int> allRecords()const;
    QArray<int> matchRegexp(const QRegExp &r) const;
-    QArray<int> queryByExample( const OPimEvent&, int, const QDateTime& d = QDateTime() );
+    QArray<int> queryByExample( const OPimEvent&, int, const QDateTime& d = QDateTime() )const;
    OPimEvent find( int uid )const;
    void clear();
    bool add( const OPimEvent& ev );
    bool remove( int uid );
    bool replace( const OPimEvent& ev );
    QArray<UID> rawEvents()const;
    QArray<UID> rawRepeats()const;
    QArray<UID> nonRepeats()const;
    OPimEvent::ValueList directNonRepeats()const;
    OPimEvent::ValueList directRawRepeats()const;
 private:
    bool m_changed :1 ;
    bool m_noTimeZone : 1;
    bool loadFile();
    inline void finalizeRecord( OPimEvent& ev );
    inline void setField( OPimEvent&, int field, const QString& val );
    QString m_name;
    QMap<int, OPimEvent> m_raw;
    QMap<int, OPimEvent> m_rep;
    struct Data;
    Data* data;
    class Private;
    Private *d;
 };
 }
 #endif
diff --git a/library/lightstyle.cpp b/library/lightstyle.cpp
index c5073ca..3d5adfb 100644
--- a/library/lightstyle.cpp
+++ b/library/lightstyle.cpp
@@ -1,1288 +1,1288 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "lightstyle.h"
 #if QT_VERSION < 0x030000
 #define INCLUDE_MENUITEM_DEF
 #include "qmenubar.h"
 #include "qapplication.h"
 #include "qpainter.h"
 #include "qpalette.h"
 #include "qframe.h"
 #include "qpushbutton.h"
 #include "qdrawutil.h"
 #include "qscrollbar.h"
 #include "qtabbar.h"
 #include "qguardedptr.h"
 #include "qlayout.h"
 #include "qlineedit.h"
 class LightStylePrivate
 {
 public:
    LightStylePrivate()
        : hoverWidget(0), ref(1), savePalette(0)
    {
    }
    QGuardedPtr<QWidget> hoverWidget;
    QPalette oldPalette, hoverPalette;
    int ref;
    QPoint mousePos;
    QPalette *savePalette;
 };
 static LightStylePrivate *singleton = 0;
 LightStyle::LightStyle()
    : QWindowsStyle()
 {
    if (! singleton) {
        singleton = new LightStylePrivate;
        QPalette pal = QApplication::palette();
        singleton->oldPalette = pal;
        QColor bg = pal.color(QPalette::Active, QColorGroup::Background);
        QColor prelight;
        if ( (bg.red() + bg.green() + bg.blue()) / 3 > 128)
            prelight = pal.color(QPalette::Active,
                                 QColorGroup::Background).light(110);
        else
            prelight = pal.color(QPalette::Active,
                                 QColorGroup::Background).light(120);
        QColorGroup active2(pal.color(QPalette::Active,
                                      QColorGroup::Foreground),      // foreground
                            prelight,                                // button
                            prelight.light(),                        // light
                            prelight.dark(),                         // dark
                            prelight.dark(120),                      // mid
                            pal.color(QPalette::Active,
                                      QColorGroup::Text),            // text
                            pal.color(QPalette::Active,
                                      QColorGroup::BrightText),      // bright text
                            pal.color(QPalette::Active,
                                      QColorGroup::Base),            // base
                            bg);                                     // background
        active2.setColor(QColorGroup::Highlight,
                         pal.color(QPalette::Active, QColorGroup::Highlight));
        singleton->hoverPalette = pal;
        singleton->hoverPalette.setActive(active2);
         singleton->hoverPalette.setInactive(active2);
    } else
        singleton->ref++;
 }
 LightStyle::~LightStyle()
 {
    if (singleton && singleton->ref-- <= 0) {
        delete singleton;
        singleton = 0;
    }
 }
 QSize LightStyle::scrollBarExtent() const
 {
    return QSize(12 + defaultFrameWidth(), 12 + defaultFrameWidth());
 }
 int LightStyle::buttonDefaultIndicatorWidth() const
 {
    return 2;
 }
 int LightStyle::sliderThickness() const
 {
    return 16;
 }
 int LightStyle::sliderLength() const
 {
    return 13;
 }
 int LightStyle::buttonMargin() const
 {
    return 4;
 }
 QSize LightStyle::exclusiveIndicatorSize() const
 {
    return QSize(13, 13);
 }
 int LightStyle::defaultFrameWidth() const
 {
    return 2;
 }
 QSize LightStyle::indicatorSize() const
 {
    return QSize(13, 13);
 }
 void LightStyle::polish(QWidget *widget)
 {
    if (widget->inherits("QPushButton"))
        widget->installEventFilter(this);
 #if QT_VERSION >= 0x030000
    if (widget->inherits("QLineEdit")) {
        QLineEdit *lineedit = (QLineEdit *) widget;
        lineedit->setFrameShape(QFrame::StyledPanel);
        lineedit->setLineWidth(2);
    }
 #endif
    QWindowsStyle::polish(widget);
 }
 void LightStyle::unPolish(QWidget *widget)
 {
    if (widget->inherits("QPushButton"))
        widget->removeEventFilter(this);
 #if QT_VERSION >= 0x030000
    if (widget->inherits("QLineEdit")) {
        QLineEdit *lineedit = (QLineEdit *) widget;
        lineedit->setLineWidth(1);
        lineedit->setFrameShape(QFrame::WinPanel);
    }
 #endif
    QWindowsStyle::unPolish(widget);
 }
 void LightStyle::polish(QApplication *app)
 {
    QPalette pal = app->palette();
    QColorGroup active(pal.color(QPalette::Active,
                                 QColorGroup::Foreground),           // foreground
                       pal.color(QPalette::Active,
                                 QColorGroup::Button),               // button
                       pal.color(QPalette::Active,
                                 QColorGroup::Background).light(),   // light
                       pal.color(QPalette::Active,
                                 QColorGroup::Background).dark(175), // dark
                       pal.color(QPalette::Active,
                                 QColorGroup::Background).dark(110), // mid
                       pal.color(QPalette::Active,
                                 QColorGroup::Text),                 // text
                       pal.color(QPalette::Active,
                                 QColorGroup::BrightText),           // bright text
                       pal.color(QPalette::Active,
                                 QColorGroup::Base),                 // base
                       pal.color(QPalette::Active,
                                 QColorGroup::Background)),          // background
        disabled(pal.color(QPalette::Disabled,
                           QColorGroup::Foreground),                 // foreground
                 pal.color(QPalette::Disabled,
                           QColorGroup::Button),                     // button
                 pal.color(QPalette::Disabled,
                           QColorGroup::Background).light(),         // light
                 pal.color(QPalette::Disabled,
                           QColorGroup::Background).dark(),          // dark
                 pal.color(QPalette::Disabled,
                           QColorGroup::Background).dark(110),       // mid
                 pal.color(QPalette::Disabled,
                           QColorGroup::Text),                       // text
                 pal.color(QPalette::Disabled,
                           QColorGroup::BrightText),                 // bright text
                 pal.color(QPalette::Disabled,
                           QColorGroup::Base),                       // base
                 pal.color(QPalette::Disabled,
                           QColorGroup::Background));                // background
    active.setColor(QColorGroup::Highlight,
                    pal.color(QPalette::Active, QColorGroup::Highlight));
    disabled.setColor(QColorGroup::Highlight,
                      pal.color(QPalette::Disabled, QColorGroup::Highlight));
    active.setColor(QColorGroup::HighlightedText,
                    pal.color(QPalette::Active, QColorGroup::HighlightedText));
    disabled.setColor(QColorGroup::HighlightedText,
                      pal.color(QPalette::Disabled, QColorGroup::HighlightedText));
    pal.setActive(active);
    pal.setInactive(active);
    pal.setDisabled(disabled);
    singleton->oldPalette = pal;
    QColor bg = pal.color(QPalette::Active, QColorGroup::Background);
    QColor prelight;
    if ( (bg.red() + bg.green() + bg.blue()) / 3 > 128)
        prelight = pal.color(QPalette::Active,
                             QColorGroup::Background).light(110);
    else
        prelight = pal.color(QPalette::Active,
                             QColorGroup::Background).light(120);
    QColorGroup active2(pal.color(QPalette::Active,
                                  QColorGroup::Foreground),      // foreground
                        prelight,                                // button
                        prelight.light(),                        // light
                        prelight.dark(),                         // dark
                        prelight.dark(120),                      // mid
                        pal.color(QPalette::Active,
                                  QColorGroup::Text),            // text
                        pal.color(QPalette::Active,
                                  QColorGroup::BrightText),      // bright text
                        pal.color(QPalette::Active,
                                  QColorGroup::Base),            // base
                        bg);                                     // background
    active2.setColor(QColorGroup::Highlight,
                     pal.color(QPalette::Active, QColorGroup::Highlight));
    singleton->hoverPalette = pal;
    singleton->hoverPalette.setActive(active2);
    singleton->hoverPalette.setInactive(active2);
    app->setPalette(pal);
 }
 void LightStyle::unPolish(QApplication *app)
 {
    app->setPalette(singleton->oldPalette);
 }
 void LightStyle::polishPopupMenu(QPopupMenu *menu)
 {
    menu->setMouseTracking(TRUE);
 }
 void LightStyle::drawPushButton(QPushButton *button, QPainter *p)
 {
    int x1, y1, x2, y2;
    button->rect().coords(&x1, &y1, &x2, &y2);
    if (button->isDefault()) {
        p->save();
        p->setPen(button->palette().active().color(QColorGroup::Highlight));
        p->setBrush(button->palette().active().brush(QColorGroup::Highlight));
        p->drawRoundRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1, 15, 15);
        p->restore();
    }
    if (button->isDefault() || button->autoDefault()) {
        x1 += buttonDefaultIndicatorWidth();
        y1 += buttonDefaultIndicatorWidth();
        x2 -= buttonDefaultIndicatorWidth();
        y2 -= buttonDefaultIndicatorWidth();
        if (button->isDefault()) {
            QPointArray pa(8);
            pa.setPoint(0, x1 + 2, y1    );
            pa.setPoint(1, x2 - 1, y1    );
            pa.setPoint(2, x2 + 1, y1 + 2);
            pa.setPoint(3, x2 + 1, y2 - 2);
            pa.setPoint(4, x2 - 2, y2 + 1);
            pa.setPoint(5, x1 + 2, y2 + 1);
            pa.setPoint(6, x1,     y2 - 1);
            pa.setPoint(7, x1,     y1 + 2);
            QRegion r(pa);
            p->setClipRegion(r);
        }
    }
    QBrush fill;
    if (button->isDown() || button->isOn())
        fill = button->colorGroup().brush(QColorGroup::Mid);
    else
        fill = button->colorGroup().brush(QColorGroup::Button);
    if ( !button->isFlat() || button->isOn() || button->isDown() )
        drawButton(p, x1, y1, x2 - x1 + 1, y2 - y1 + 1,
                   button->colorGroup(), button->isOn() || button->isDown(), &fill);
 }
 void LightStyle::drawButton(QPainter *p, int x, int y, int w, int h,
                                 const QColorGroup &g,
                                 bool sunken, const QBrush *fill)
 {
    p->save();
    if ( fill )
        p->fillRect(x + 2, y + 2, w - 4, h - 4, *fill);
    else
        p->fillRect(x + 2, y + 2, w - 4, h - 4,
                    QBrush(sunken ? g.mid() : g.button()));
    // frame
    p->setPen(g.dark());
    p->drawLine(x, y + 2, x, y + h - 3); // left
    p->drawLine(x + 2, y, x + w - 3, y); // top
    p->drawLine(x + w - 1, y + 2, x + w - 1, y + h - 3); // right
    p->drawLine(x + 2, y + h - 1, x + w - 3, y + h - 1); // bottom
    p->drawPoint(x + 1, y + 1);
    p->drawPoint(x + 1, y + h - 2);
    p->drawPoint(x + w - 2, y + 1);
    p->drawPoint(x + w - 2, y + h - 2);
    // bevel
    if (sunken)
        p->setPen(g.mid());
    else
        p->setPen(g.light());
    p->drawLine(x + 1, y + 2, x + 1, y + h - 3); // left
    p->drawLine(x + 2, y + 1, x + w - 3, y + 1); // top
    if (sunken)
        p->setPen(g.light());
    else
        p->setPen(g.mid());
    p->drawLine(x + w - 2, y + 2, x + w - 2, y + h - 3); // right + 1
    p->drawLine(x + 2, y + h - 2, x + w - 3, y + h - 2); // bottom + 1
    p->restore();
 }
 void LightStyle::drawBevelButton(QPainter *p, int x, int y, int w, int h,
                                      const QColorGroup &g,
                                      bool sunken, const QBrush *fill)
 {
    drawButton(p, x, y, w, h, g, sunken, fill);
 }
-void LightStyle::getButtonShift(int &x, int &y) const
+void LightStyle::getButtonShift(int &x, int &y)
 {
    x = y = 0;
 }
 void LightStyle::drawComboButton(QPainter *p, int x, int y, int w, int h,
                               const QColorGroup &g, bool,
                               bool editable, bool,
                               const QBrush *fill)
 {
    drawButton(p, x, y, w, h, g, FALSE, fill);
    if (editable) {
        QRect r = comboButtonRect(x, y, w, h);
        qDrawShadePanel(p, r.x() - 1, r.y() - 1,
                        r.width() + defaultFrameWidth(),
                        r.height() + defaultFrameWidth(),
                        g, TRUE);
    }
    int indent = ((y + h) / 2) - 3;
    int xpos = x;
 #if QT_VERSION >= 0x030000
    if( QApplication::reverseLayout() )
        xpos += indent;
    else
 #endif
        xpos += w - indent - 5;
    drawArrow(p, Qt::DownArrow, TRUE, xpos, indent, 5, 5, g, TRUE, fill);
 }
-QRect LightStyle::comboButtonRect( int x, int y, int w, int h ) const
+QRect LightStyle::comboButtonRect( int x, int y, int w, int h )
 {
    QRect r(x + 3, y + 3, w - 6, h - 6);
    int indent = ((y + h) / 2) - 3;
    r.setRight(r.right() - indent - 10);
 #if QT_VERSION >= 0x030000
    if( QApplication::reverseLayout() )
        r.moveBy( indent + 10, 0 );
 #endif
    return r;
 }
-QRect LightStyle::comboButtonFocusRect(int x, int y, int w, int h ) const
+QRect LightStyle::comboButtonFocusRect(int x, int y, int w, int h )
 {
    return comboButtonRect(x, y, w, h);
 }
 void LightStyle::drawPanel(QPainter *p, int x, int y, int w, int h,
                         const QColorGroup &g, bool sunken,
                         int lw, const QBrush *fill)
 {
    if (lw >= 2) {
        if ( fill )
            p->fillRect(x + 2, y + 2, w - 4, h - 4, *fill);
        QPen oldpen = p->pen();
        // frame
        p->setPen(g.dark());
        p->drawLine(x, y + 2, x, y + h - 3); // left
        p->drawLine(x + 2, y, x + w - 3, y); // top
        p->drawLine(x + w - 1, y + 2, x + w - 1, y + h - 3); // right
        p->drawLine(x + 2, y + h - 1, x + w - 3, y + h - 1); // bottom
        p->drawPoint(x + 1, y + 1);
        p->drawPoint(x + 1, y + h - 2);
        p->drawPoint(x + w - 2, y + 1);
        p->drawPoint(x + w - 2, y + h - 2);
        // bevel
        if (sunken)
            p->setPen(g.mid());
        else
            p->setPen(g.light());
        p->drawLine(x + 1, y + 2, x + 1, y + h - 3); // left
        p->drawLine(x + 2, y + 1, x + w - 3, y + 1); // top
        if (sunken)
            p->setPen(g.light());
        else
            p->setPen(g.mid());
        p->drawLine(x + w - 2, y + 2, x + w - 2, y + h - 3); // right + 1
        p->drawLine(x + 2, y + h - 2, x + w - 3, y + h - 2); // bottom + 1
        // corners
        p->setPen(g.background());
        p->drawLine(x, y, x + 1, y);
        p->drawLine(x, y + h - 1, x + 1, y + h - 1);
        p->drawLine(x + w - 2, y, x + w - 1, y);
        p->drawLine(x + w - 2, y + h - 1, x + w - 1, y + h - 1);
        p->drawPoint(x, y + 1);
        p->drawPoint(x, y + h - 2);
        p->drawPoint(x + w - 1, y + 1);
        p->drawPoint(x + w - 1, y + h - 2);
        p->setPen(oldpen);
    } else
        qDrawShadePanel(p, x, y, w, h, g, sunken, lw, fill);
 }
 void LightStyle::drawIndicator(QPainter *p, int x, int y ,int w, int h,
                               const QColorGroup &g, int state,
                               bool down, bool)
 {
    drawButton(p, x, y, w, h, g, TRUE,
               &g.brush(down ? QColorGroup::Mid : QColorGroup::Base));
    p->save();
    p->setPen(g.foreground());
    if (state == QButton::NoChange) {
        p->drawLine(x + 3, y + h / 2, x + w - 4, y + h / 2);
        p->drawLine(x + 3, y + 1 + h / 2, x + w - 4, y + 1 + h / 2);
        p->drawLine(x + 3, y - 1 + h / 2, x + w - 4, y - 1 + h / 2);
    } else if (state == QButton::On) {
        p->drawLine(x + 4, y + 3, x + w - 4, y + h - 5);
        p->drawLine(x + 3, y + 3, x + w - 4, y + h - 4);
        p->drawLine(x + 3, y + 4, x + w - 5, y + h - 4);
        p->drawLine(x + 3, y + h - 5, x + w - 5, y + 3);
        p->drawLine(x + 3, y + h - 4, x + w - 4, y + 3);
        p->drawLine(x + 4, y + h - 4, x + w - 4, y + 4);
    }
    p->restore();
 }
 void LightStyle::drawExclusiveIndicator(QPainter *p, int x, int y, int w, int h,
                                        const QColorGroup &g, bool on,
                                        bool down, bool)
 {
    p->save();
    p->fillRect(x, y, w, h, g.brush(QColorGroup::Background));
    p->setPen(g.dark());
    p->drawArc(x, y, w, h, 0, 16*360);
    p->setPen(g.mid());
    p->drawArc(x + 1, y + 1, w - 2, h - 2, 45*16, 180*16);
    p->setPen(g.light());
    p->drawArc(x + 1, y + 1, w - 2, h - 2, 235*16, 180*16);
    p->setPen(down ? g.mid() : g.base());
    p->setBrush(down ? g.mid() : g.base());
    p->drawEllipse(x + 2, y + 2, w - 4, h - 4);
    if (on) {
        p->setBrush(g.foreground());
        p->drawEllipse(x + 3, y + 3, w - x - 6, h - y - 6);
    }
    p->restore();
 }
 #if 1
 //copied from QPE style
 void LightStyle::drawTab( QPainter *p, const QTabBar *tb, QTab *t, bool selected )
 {
 #if 0
    //We can't do this, because QTabBar::focusInEvent redraws the
    // tab label with the default font.
        QFont f = tb->font();
        f.setBold( selected );
        p->setFont( f );
 #endif
    QRect r( t->rect() );
    if ( tb->shape()  == QTabBar::RoundedAbove ) {
        p->setPen( tb->colorGroup().light() );
        p->drawLine( r.left(), r.bottom(), r.right(), r.bottom() );
        if ( r.left() == 0 )
            p->drawPoint( tb->rect().bottomLeft() );
        else {
            p->setPen( tb->colorGroup().light() );
            p->drawLine( r.left(), r.bottom(), r.right(), r.bottom() );
        }
        if ( selected ) {
            p->setPen( tb->colorGroup().background() );
            p->drawLine( r.left()+2, r.top()+1, r.right()-2, r.top()+1 );
            p->fillRect( QRect( r.left()+1, r.top()+2, r.width()-2, r.height()-2),
                         tb->colorGroup().brush( QColorGroup::Background ));
        } else {
            r.setRect( r.left() + 2, r.top() + 2,
                       r.width() - 4, r.height() - 2 );
            p->setPen( tb->colorGroup().button() );
            p->drawLine( r.left()+2, r.top()+1, r.right()-2, r.top()+1 );
            p->fillRect( QRect( r.left()+1, r.top()+2, r.width()-2, r.height()-3),
                         tb->colorGroup().brush( QColorGroup::Button ));
            //do shading; will not work for pixmap brushes
            QColor bg = tb->colorGroup().button();
                    //    int h,s,v;
                    //    bg.hsv( &h, &s, &v );
            int n = r.height()/2;
            int dark = 100;
            for ( int i = 1; i < n; i++ ) {
                dark = (dark * (100+(i*15)/n) )/100;
                p->setPen( bg.dark( dark ) );
                int y = r.bottom()-n+i;
                int x1 = r.left()+1;
                int x2 = r.right()-1;
                p->drawLine( x1, y, x2, y );
            }
        }
        p->setPen( tb->colorGroup().light() );
        p->drawLine( r.left(), r.bottom()-1, r.left(), r.top() + 2 );
        p->drawPoint( r.left()+1, r.top() + 1 );
        p->drawLine( r.left()+2, r.top(),
                     r.right() - 2, r.top() );
        p->setPen( tb->colorGroup().dark() );
        p->drawPoint( r.right() - 1, r.top() + 1 );
        p->drawLine( r.right(), r.top() + 2, r.right(), r.bottom() - 1);
    } else if ( tb->shape() == QTabBar::RoundedBelow ) {
        if ( selected ) {
            p->setPen( tb->colorGroup().background() );
            p->drawLine( r.left()+2, r.bottom()-1, r.right()-2, r.bottom()-1 );
            p->fillRect( QRect( r.left()+1, r.top(), r.width()-2, r.height()-2),
                         tb->palette().normal().brush( QColorGroup::Background ));
        } else {
            p->setPen( tb->colorGroup().dark() );
            p->drawLine( r.left(), r.top(),
                         r.right(), r.top() );
            r.setRect( r.left() + 2, r.top(),
                       r.width() - 4, r.height() - 2 );
            p->setPen( tb->colorGroup().button() );
            p->drawLine( r.left()+2, r.bottom()-1, r.right()-2, r.bottom()-1 );
            p->fillRect( QRect( r.left()+1, r.top()+1, r.width()-2, r.height()-3),
                         tb->palette().normal().brush( QColorGroup::Button ));
        }
        p->setPen( tb->colorGroup().dark() );
        p->drawLine( r.right(), r.top(),
                     r.right(), r.bottom() - 2 );
        p->drawPoint( r.right() - 1, r.bottom() - 1 );
        p->drawLine( r.right() - 2, r.bottom(),
                     r.left() + 2, r.bottom() );
        p->setPen( tb->colorGroup().light() );
        p->drawLine( r.left(), r.top()+1,
                     r.left(), r.bottom() - 2 );
        p->drawPoint( r.left() + 1, r.bottom() - 1 );
        if ( r.left() == 0 )
            p->drawPoint( tb->rect().topLeft() );
    } else {
        QCommonStyle::drawTab( p, tb, t, selected );
    }
 }
 #else
 void LightStyle::drawTab(QPainter *p, const QTabBar *tabbar, QTab *tab,
                              bool selected)
 {
    p->save();
    QColorGroup g = tabbar->colorGroup();
    QRect fr(tab->r);
    fr.setLeft(fr.left() + 2);
    if (! selected) {
        if (tabbar->shape() == QTabBar::RoundedAbove ||
            tabbar->shape() == QTabBar::TriangularAbove) {
            fr.setTop(fr.top() + 2);
        } else {
            fr.setBottom(fr.bottom() - 2);
        }
    }
    QRegion tabr(tab->r);
    QPointArray cliptri(4);
    cliptri.setPoint(0, fr.left(), fr.top());
    cliptri.setPoint(1, fr.left(), fr.top() + 5);
    cliptri.setPoint(2, fr.left() + 5, fr.top());
    cliptri.setPoint(3, fr.left(), fr.top());
    QRegion trir(cliptri);
    p->setClipRegion(tabr - trir);
    p->setPen( NoPen );
    p->setBrush(g.brush(selected ? QColorGroup::Background : QColorGroup::Mid));
    fr.setWidth(fr.width() - 1);
    p->drawRect(fr.left() + 1, fr.top() + 1, fr.width() - 2, fr.height() - 2);
    if (tabbar->shape() == QTabBar::RoundedAbove) {
        // "rounded" tabs on top
        fr.setBottom(fr.bottom() - 1);
        p->setPen(g.dark());
        p->drawLine(fr.left(), fr.top() + 5, fr.left(), fr.bottom() - 1);
        p->drawLine(fr.left(), fr.top() + 5, fr.left() + 5, fr.top());
        p->drawLine(fr.left() + 5, fr.top(), fr.right() - 1, fr.top());
        p->drawLine(fr.right(), fr.top() + 1, fr.right(), fr.bottom() - 1);
        if (selected) {
            p->drawLine(fr.right(), fr.bottom(), fr.right() + 2, fr.bottom());
            p->drawPoint(fr.left(), fr.bottom());
        } else
            p->drawLine(fr.left(), fr.bottom(), fr.right() + 2, fr.bottom());
        if (fr.left() == 2) {
            p->drawPoint(fr.left() - 1, fr.bottom() + 1);
            p->drawPoint(fr.left() - 2, fr.bottom() + 2);
        }
        if (selected) {
            p->setPen(g.mid());
            p->drawLine(fr.right() - 1, fr.top() + 1, fr.right() - 1, fr.bottom() - 2);
        }
        p->setPen(g.light()); p->setPen(red);
        p->drawLine(fr.left() + 1, fr.top() + 6, fr.left() + 1,
                    fr.bottom() - (selected ? 0 : 1));
        p->drawLine(fr.left() + 1, fr.top() + 5, fr.left() + 5, fr.top() + 1);
        p->drawLine(fr.left() + 6, fr.top() + 1, fr.right() - 3, fr.top() + 1);
        if (selected) {
            p->drawLine(fr.right() + 1, fr.bottom() + 1,
                        fr.right() + 2, fr.bottom() + 1);
            p->drawLine(fr.left(), fr.bottom() + 1, fr.left() + 1, fr.bottom() + 1);
        } else
            p->drawLine(fr.left(), fr.bottom() + 1,
                        fr.right() + 2, fr.bottom() + 1);
    } else if (tabbar->shape() == QTabBar::RoundedBelow) {
        // "rounded" tabs on bottom
        fr.setTop(fr.top() + 1);
        p->setPen(g.dark());
        p->drawLine(fr.left(), fr.top(), fr.left(), fr.bottom() - 1);
        p->drawLine(fr.left() + 1, fr.bottom(), fr.right() - 1, fr.bottom());
        p->drawLine(fr.right(), fr.top(), fr.right(), fr.bottom() - 1);
        if (! selected)
            p->drawLine(fr.left(), fr.top(), fr.right() + 3, fr.top());
        else
            p->drawLine(fr.right(), fr.top(), fr.right() + 3, fr.top());
        p->setPen(g.mid());
        if (selected)
            p->drawLine(fr.right() - 1, fr.top() + 1, fr.right() - 1, fr.bottom() - 1);
        else
            p->drawLine(fr.left(), fr.top() - 1, fr.right() + 3, fr.top() - 1);
        p->setPen(g.light());
        p->drawLine(fr.left() + 1, fr.top() + (selected ? -1 : 2),
                    fr.left() + 1, fr.bottom() - 1);
    } else {
        // triangular drawing code
        QCommonStyle::drawTab(p, tabbar, tab, selected);
    }
    p->restore();
 }
 #endif
 void LightStyle::drawSlider(QPainter *p, int x, int y, int w, int h,
                          const QColorGroup &g, Qt::Orientation orientation,
                          bool above, bool below)
 {
    drawButton(p, x, y, w, h, g, FALSE, &g.brush(QColorGroup::Button));
    if (orientation == Horizontal) {
        if (above && below) {
            drawArrow(p, Qt::UpArrow, FALSE, x + 1, y + 1, w, h / 2, g, TRUE);
            drawArrow(p, Qt::DownArrow, FALSE, x + 1, y + (h / 2) - 1,
                      w, h / 2, g, TRUE);
        } else
            drawArrow(p, (above) ? Qt::UpArrow : Qt::DownArrow,
                      FALSE, x + 1, y, w, h, g, TRUE);
    } else {
        if (above && below) {
            drawArrow(p, Qt::LeftArrow, FALSE, x + 1, y, w / 2, h, g, TRUE);
            drawArrow(p, Qt::RightArrow, FALSE, x + (w / 2) - 2, y, w / 2, h, g, TRUE);
        } else
            drawArrow(p, (above) ? Qt::LeftArrow : Qt::RightArrow,
                      FALSE, x, y, w, h, g, TRUE);
    }
 }
 void LightStyle::drawSliderGroove(QPainter *p, int x, int y, int w, int h,
                                const QColorGroup& g, QCOORD c,
                                Qt::Orientation orientation)
 {
    if (orientation == Horizontal)
        drawButton(p, x, y+c - 3, w, 6, g, TRUE, &g.brush(QColorGroup::Mid));
    else
        drawButton(p, x+c - 3, y, 6, h, g, TRUE, &g.brush(QColorGroup::Mid));
 }
 void LightStyle::scrollBarMetrics(const QScrollBar *scrollbar,
                                       int &sliderMin, int &sliderMax,
-                                       int &sliderLength, int &buttonDim) const
+                                       int &sliderLength, int &buttonDim)
 {
    int maxLength;
    int length = ((scrollbar->orientation() == Horizontal) ?
                  scrollbar->width() : scrollbar->height());
    int extent = ((scrollbar->orientation() == Horizontal) ?
                  scrollbar->height() : scrollbar->width());
    extent--;
    if (length > (extent + defaultFrameWidth() - 1) * 2 + defaultFrameWidth())
        buttonDim = extent - defaultFrameWidth();
    else
        buttonDim = (length - defaultFrameWidth()) / 2 - 1;
    sliderMin = buttonDim;
    maxLength = length - buttonDim * 3;
    if (scrollbar->maxValue() != scrollbar->minValue()) {
        uint range = scrollbar->maxValue() - scrollbar->minValue();
        sliderLength = (scrollbar->pageStep() * maxLength) /
                       (range + scrollbar->pageStep());
        if (sliderLength < buttonDim || range > INT_MAX / 2)
            sliderLength = buttonDim;
        if (sliderLength > maxLength)
            sliderLength = maxLength;
    } else
        sliderLength = maxLength;
    sliderMax = sliderMin + maxLength - sliderLength;
 }
 QStyle::ScrollControl LightStyle::scrollBarPointOver(const QScrollBar *scrollbar,
                                                   int sliderStart, const QPoint &p)
 {
    if (! scrollbar->rect().contains(p))
        return NoScroll;
    int sliderMin, sliderMax, sliderLength, buttonDim, pos;
    scrollBarMetrics( scrollbar, sliderMin, sliderMax, sliderLength, buttonDim );
    if (scrollbar->orientation() == Horizontal)
        pos = p.x();
    else
        pos = p.y();
    if (pos < buttonDim)
        return SubLine;
    if (pos < sliderStart)
        return SubPage;
    if (pos < sliderStart + sliderLength)
        return Slider;
    if (pos < sliderMax + sliderLength)
        return AddPage;
    if (pos < sliderMax + sliderLength + buttonDim)
        return SubLine;
    return AddLine;
 }
 void LightStyle::drawScrollBarControls( QPainter* p, const QScrollBar* scrollbar,
                                             int sliderStart, uint controls,
                                             uint activeControl )
 {
    QColorGroup g  = scrollbar->colorGroup();
    int sliderMin, sliderMax, sliderLength, buttonDim;
    scrollBarMetrics( scrollbar, sliderMin, sliderMax, sliderLength, buttonDim );
    if (sliderStart > sliderMax) { // sanity check
        sliderStart = sliderMax;
    }
    QRect addR, subR, subR2, addPageR, subPageR, sliderR;
    int length =  ((scrollbar->orientation() == Horizontal) ?
                   scrollbar->width()  : scrollbar->height());
    int extent =  ((scrollbar->orientation() == Horizontal) ?
                   scrollbar->height() : scrollbar->width());
    int fudge = 3; //####disgusting hack
    if (scrollbar->orientation() == Horizontal) {
        subR.setRect(0, defaultFrameWidth(),
                     buttonDim + fudge, buttonDim);
        subR2.setRect(length - (buttonDim * 2), defaultFrameWidth() ,
                      buttonDim, buttonDim);
        addR.setRect(length - buttonDim, defaultFrameWidth(),
                     buttonDim, buttonDim);
    } else {
        subR.setRect(defaultFrameWidth() + 1, 0,
                     buttonDim, buttonDim + fudge);
        subR2.setRect(defaultFrameWidth() + 1, length - (buttonDim * 2),
                      buttonDim, buttonDim);
        addR.setRect(defaultFrameWidth() + 1, length - buttonDim,
                     buttonDim, buttonDim);
    }
    int sliderEnd = sliderStart + sliderLength;
    int sliderW = extent - defaultFrameWidth() - 1;
    if (scrollbar->orientation() == Horizontal) {
        subPageR.setRect( subR.right() + 1, defaultFrameWidth(),
                          sliderStart - subR.right() - 1 , sliderW );
        addPageR.setRect( sliderEnd, defaultFrameWidth(),
                          subR2.left() - sliderEnd, sliderW );
        sliderR.setRect( sliderStart, defaultFrameWidth(), sliderLength, sliderW );
    } else {
        subPageR.setRect( defaultFrameWidth(), subR.bottom() + 1,
                          sliderW, sliderStart - subR.bottom() - 1 );
        addPageR.setRect( defaultFrameWidth(), sliderEnd,
                          sliderW, subR2.top() - sliderEnd );
        sliderR .setRect( defaultFrameWidth(), sliderStart,
                          sliderW, sliderLength );
    }
    if ( controls == ( AddLine | SubLine | AddPage | SubPage |
                       Slider | First | Last ) ) {
        if (scrollbar->orientation() == Horizontal)
            qDrawShadePanel(p, 0, 0, length, 2, g, TRUE, 1,
                            &g.brush(QColorGroup::Background));
        else
            qDrawShadePanel(p, 0, 0, 2, length, g, TRUE, 1,
                            &g.brush(QColorGroup::Background));
    }
    if ( controls & AddLine )
        drawArrow( p, (scrollbar->orientation() == Vertical) ? DownArrow : RightArrow,
                   FALSE, addR.x(), addR.y(),
                   addR.width(), addR.height(),
                   (( activeControl == AddLine ) ?
                    singleton->hoverPalette.active() : g),
                   TRUE, &g.brush(QColorGroup::Background));
    if ( controls & SubLine ) {
        drawArrow( p, (scrollbar->orientation() == Vertical) ? UpArrow : LeftArrow,
                   FALSE, subR.x(), subR.y(),
                   subR.width(), subR.height(),
                   (( activeControl == SubLine ) ?
                    singleton->hoverPalette.active() : g),
                   TRUE, &g.brush(QColorGroup::Background));
        drawArrow( p, (scrollbar->orientation() == Vertical) ? UpArrow : LeftArrow,
                   FALSE, subR2.x(), subR2.y(),
                   subR2.width(), subR2.height(),
                   (( activeControl == SubLine ) ?
                    singleton->hoverPalette.active() : g),
                   TRUE, &g.brush(QColorGroup::Background));
    }
    if ( controls & SubPage )
        p->fillRect( subPageR,
                     ((activeControl == SubPage) ?
                      g.brush( QColorGroup::Dark ) :
                      g.brush( QColorGroup::Mid )));
    if ( controls & AddPage )
        p->fillRect( addPageR,
                     ((activeControl == AddPage) ?
                      g.brush( QColorGroup::Dark ) :
                      g.brush( QColorGroup::Mid )));
    if ( controls & Slider ) {
        QPoint bo = p->brushOrigin();
        p->setBrushOrigin(sliderR.topLeft());
        if ( sliderR.isValid() ) {
            p->fillRect( sliderR.x(), sliderR.y(), 2, 2,
                      g.brush( QColorGroup::Mid ));
            p->fillRect( sliderR.x() + sliderR.width() - 2,
                    sliderR.y(), 2, 2,
                      g.brush( QColorGroup::Mid ));
            p->fillRect( sliderR.x() + sliderR.width() - 2,
                    sliderR.y() + sliderR.height() - 2, 2, 2,
                      g.brush( QColorGroup::Mid ));
            p->fillRect( sliderR.x(),
                    sliderR.y() + sliderR.height() - 2, 2, 2,
                      g.brush( QColorGroup::Mid ));
            QColorGroup cg( g );
            cg.setBrush( QColorGroup::Background, g.brush( QColorGroup::Mid ) );
            drawBevelButton( p, sliderR.x(), sliderR.y(),
                             sliderR.width(), sliderR.height(),
                             cg, FALSE, &g.brush( QColorGroup::Button ) );
        }
        p->setBrushOrigin(bo);
    }
 }
 void LightStyle::drawToolBarHandle(QPainter *p, const QRect &rect,
                                   Qt::Orientation orientation,
                                   bool, const QColorGroup &g, bool)
 {
    p->save();
    p->setPen(g.mid());
    p->setBrush(g.brush(QColorGroup::Mid));
    if (orientation == Qt::Horizontal) {
        QRect l, r;
        l.setRect(rect.x() + 1, rect.y() + 1, rect.width() - 5, rect.height() - 2);
        r.setRect(l.right() + 1, l.y(), 3, l.height());
        p->drawRect(l);
               qDrawShadePanel(p, r, g, FALSE);
    } else {
        QRect t, b;
        t.setRect(rect.x() + 1, rect.y() + 1, rect.width() - 2, rect.height() - 5);
        b.setRect(t.x(), t.bottom() + 1, t.width(), 3);
        p->drawRect(t);
               qDrawShadePanel(p, b, g, FALSE);
    }
    p->restore();
 }
 bool LightStyle::eventFilter(QObject *object, QEvent *event)
 {
    switch(event->type()) {
    case QEvent::Enter:
        {
            if (! object->isWidgetType() ||
                ! object->inherits("QPushButton"))
                break;
            singleton->hoverWidget = (QWidget *) object;
            if (! singleton->hoverWidget->isEnabled()) {
                singleton->hoverWidget = 0;
                break;
            }
            QPalette pal = singleton->hoverWidget->palette();
            if (singleton->hoverWidget->ownPalette())
                singleton->savePalette = new QPalette(pal);
            singleton->hoverWidget->setPalette(singleton->hoverPalette);
            break;
        }
    case QEvent::Leave:
        {
            if (object != singleton->hoverWidget)
                break;
            if (singleton->savePalette) {
                singleton->hoverWidget->setPalette(*(singleton->savePalette));
                delete singleton->savePalette;
                singleton->savePalette = 0;
            } else
                singleton->hoverWidget->unsetPalette();
            singleton->hoverWidget = 0;
            break;
        }
    default:
        {
            ;
        }
    }
    return QWindowsStyle::eventFilter(object, event);
 }
        static const int motifItemFrame                 = 1;// menu item frame width
        static const int motifSepHeight                 = 2;// separator item height
        static const int motifItemHMargin       = 1;// menu item hor text margin
        static const int motifItemVMargin       = 2;// menu item ver text margin
        static const int motifArrowHMargin      = 0;// arrow horizontal margin
        static const int motifTabSpacing        = 12;// space between text and tab
        static const int motifCheckMarkHMargin  = 1;// horiz. margins of check mark
        static const int windowsRightBorder= 8;    // right border on windows
 static const int windowsCheckMarkWidth  = 2;    // checkmarks width on windows
 /*! \reimp
 */
 int LightStyle::extraPopupMenuItemWidth( bool checkable, int maxpmw, QMenuItem* mi, const QFontMetrics& /*fm*/ )
 {
 #ifndef QT_NO_MENUDATA
    int w = 2*motifItemHMargin + 2*motifItemFrame; // a little bit of border can never harm
    if ( mi->isSeparator() )
        return 10; // arbitrary
    else if ( mi->pixmap() )
                w += mi->pixmap()->width();// pixmap only
    if ( !mi->text().isNull() ) {
                if ( mi->text().find('\t') >= 0 )// string contains tab
            w += motifTabSpacing;
    }
    if ( maxpmw ) { // we have iconsets
        w += maxpmw;
        w += 6; // add a little extra border around the iconset
    }
    if ( checkable && maxpmw < windowsCheckMarkWidth ) {
        w += windowsCheckMarkWidth - maxpmw; // space for the checkmarks
    }
    if ( maxpmw > 0 || checkable ) // we have a check-column ( iconsets or checkmarks)
        w += motifCheckMarkHMargin; // add space to separate the columns
    w += windowsRightBorder; // windows has a strange wide border on the right side
    return w;
 #endif
 }
 /*! \reimp
 */
 int LightStyle::popupMenuItemHeight( bool /*checkable*/, QMenuItem* mi, const QFontMetrics& fm )
 {
 #ifndef QT_NO_MENUDATA
    int h = 0;
            if ( mi->isSeparator() )            // separator height
        h = motifSepHeight;
            else if ( mi->pixmap() )    // pixmap height
        h = mi->pixmap()->height() + 2*motifItemFrame;
            else                                // text height
        h = fm.height() + 2*motifItemVMargin + 2*motifItemFrame;
    if ( !mi->isSeparator() && mi->iconSet() != 0 ) {
        h = QMAX( h, mi->iconSet()->pixmap().height() + 2*motifItemFrame );
    }
    if ( mi->custom() )
        h = QMAX( h, mi->custom()->sizeHint().height() + 2*motifItemVMargin + 2*motifItemFrame ) - 1;
    return h;
 #endif
 }
 void LightStyle::drawPopupMenuItem( QPainter* p, bool checkable, int maxpmw, int tab, QMenuItem* mi,
                                       const QPalette& pal,
                                       bool act, bool enabled, int x, int y, int w, int h)
 {
 #ifndef QT_NO_MENUDATA
    const QColorGroup & g = pal.active();
            bool dis  = !enabled;
    QColorGroup itemg = dis ? pal.disabled() : pal.active();
    if ( checkable )
        maxpmw = QMAX( maxpmw, 8 ); // space for the checkmarks
            int checkcol  =     maxpmw;
            if ( mi && mi->isSeparator() ) {            // draw separator
        p->setPen( g.dark() );
        p->drawLine( x, y, x+w, y );
        p->setPen( g.light() );
        p->drawLine( x, y+1, x+w, y+1 );
        return;
    }
    QBrush fill = act? g.brush( QColorGroup::Highlight ) :
                            g.brush( QColorGroup::Button );
    p->fillRect( x, y, w, h, fill);
    if ( !mi )
        return;
    if ( mi->isChecked() ) {
        if ( act && !dis ) {
            qDrawShadePanel( p, x, y, checkcol, h,
                             g, TRUE, 1, &g.brush( QColorGroup::Button ) );
        } else {
            qDrawShadePanel( p, x, y, checkcol, h,
                             g, TRUE, 1, &g.brush( QColorGroup::Midlight ) );
        }
    } else if ( !act ) {
        p->fillRect(x, y, checkcol , h,
                    g.brush( QColorGroup::Button ));
    }
            if ( mi->iconSet() ) {      // draw iconset
        QIconSet::Mode mode = dis ? QIconSet::Disabled : QIconSet::Normal;
        if (act && !dis )
            mode = QIconSet::Active;
    QPixmap pixmap;
    if ( mode == QIconSet::Disabled )
        pixmap = mi->iconSet()->pixmap( QIconSet::Automatic, mode );
    else
        pixmap = mi->iconSet()->pixmap();
        int pixw = pixmap.width();
        int pixh = pixmap.height();
        if ( act && !dis ) {
            if ( !mi->isChecked() )
                qDrawShadePanel( p, x, y, checkcol, h, g, FALSE,  1, &g.brush( QColorGroup::Button ) );
        }
        QRect cr( x, y, checkcol, h );
        QRect pmr( 0, 0, pixw, pixh );
        pmr.moveCenter( cr.center() );
        p->setPen( itemg.text() );
        p->drawPixmap( pmr.topLeft(), pixmap );
        QBrush fill = act? g.brush( QColorGroup::Highlight ) :
                              g.brush( QColorGroup::Button );
        p->fillRect( x+checkcol + 1, y, w - checkcol - 1, h, fill);
            } else  if ( checkable ) {// just "checking"...
        int mw = checkcol + motifItemFrame;
        int mh = h - 2*motifItemFrame;
        if ( mi->isChecked() ) {
            drawCheckMark( p, x + motifItemFrame + 2,
                           y+motifItemFrame, mw, mh, itemg, act, dis );
        }
    }
    p->setPen( act ? g.highlightedText() : g.buttonText() );
    QColor discol;
    if ( dis ) {
        discol = itemg.text();
        p->setPen( discol );
    }
    int xm = motifItemFrame + checkcol + motifItemHMargin;
    if ( mi->custom() ) {
        int m = motifItemVMargin;
        p->save();
        if ( dis && !act ) {
            p->setPen( g.light() );
            mi->custom()->paint( p, itemg, act, enabled,
                                 x+xm+1, y+m+1, w-xm-tab+1, h-2*m );
            p->setPen( discol );
        }
        mi->custom()->paint( p, itemg, act, enabled,
                             x+xm, y+m, w-xm-tab+1, h-2*m );
        p->restore();
    }
    QString s = mi->text();
            if ( !s.isNull() ) {                // draw text
        int t = s.find( '\t' );
        int m = motifItemVMargin;
        const int text_flags = AlignVCenter|ShowPrefix | DontClip | SingleLine;
                if ( t >= 0 ) {                         // draw tab text
            if ( dis && !act ) {
                p->setPen( g.light() );
                p->drawText( x+w-tab-windowsRightBorder-motifItemHMargin-motifItemFrame+1,
                             y+m+1, tab, h-2*m, text_flags, s.mid( t+1 ));
                p->setPen( discol );
            }
            p->drawText( x+w-tab-windowsRightBorder-motifItemHMargin-motifItemFrame,
                         y+m, tab, h-2*m, text_flags, s.mid( t+1 ) );
        }
        if ( dis && !act ) {
            p->setPen( g.light() );
            p->drawText( x+xm+1, y+m+1, w-xm+1, h-2*m, text_flags, s, t );
            p->setPen( discol );
        }
        p->drawText( x+xm, y+m, w-xm-tab+1, h-2*m, text_flags, s, t );
            } else if ( mi->pixmap() ) {                // draw pixmap
        QPixmap *pixmap = mi->pixmap();
        if ( pixmap->depth() == 1 )
            p->setBackgroundMode( OpaqueMode );
        p->drawPixmap( x+xm, y+motifItemFrame, *pixmap );
        if ( pixmap->depth() == 1 )
            p->setBackgroundMode( TransparentMode );
    }
            if ( mi->popup() ) {                // draw sub menu arrow
        int dim = (h-2*motifItemFrame) / 2;
        if ( act ) {
            if ( !dis )
                discol = white;
            QColorGroup g2( discol, g.highlight(),
                            white, white,
                            dis ? discol : white,
                            discol, white );
            drawArrow( p, RightArrow, FALSE,
                               x+w - motifArrowHMargin - motifItemFrame - dim,  y+h/2-dim/2,
                               dim, dim, g2, TRUE );
        } else {
            drawArrow( p, RightArrow,
                               FALSE,
                               x+w - motifArrowHMargin - motifItemFrame - dim,  y+h/2-dim/2,
                               dim, dim, g, mi->isEnabled() );
        }
    }
 #endif
 }
 #endif
diff --git a/library/lightstyle.h b/library/lightstyle.h
index 0392957..52e19b2 100644
--- a/library/lightstyle.h
+++ b/library/lightstyle.h
@@ -1,120 +1,120 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef LIGHTSTYLE_H
 #define LIGHTSTYLE_H
 #ifndef QT_H
 #include <qstyle.h>
 #include <qwindowsstyle.h>
 #endif // QT_H
 #if QT_VERSION < 0x030000
 #ifdef QT_PLUGIN_STYLE_LIGHT
 #  define Q_EXPORT_STYLE_LIGHT
 #else
 #  define Q_EXPORT_STYLE_LIGHT Q_EXPORT
 #endif // QT_PLUGIN_STYLE_LIGHT
 class Q_EXPORT_STYLE_LIGHT LightStyle : public QWindowsStyle
 {
 public:
    LightStyle();
    virtual ~LightStyle();
    void polish(QWidget *widget);
    void unPolish(QWidget*widget);
    void polish(QApplication *app);
    void unPolish(QApplication *app);
    void polishPopupMenu(QPopupMenu *menu);
    void drawPushButton(QPushButton *button, QPainter *p);
    void drawButton(QPainter *p, int x, int y, int w, int h,
                    const QColorGroup &g, bool sunken = FALSE,
                    const QBrush *fill = 0);
    void drawBevelButton(QPainter *p, int x, int y, int w, int h,
                         const QColorGroup &g, bool sunken = FALSE,
                         const QBrush *fill = 0);
-    void getButtonShift(int &x, int &y) const;
+    void getButtonShift(int &x, int &y);
    void drawComboButton(QPainter *p, int x, int y, int w, int h,
                         const QColorGroup &g, bool sunken = FALSE,
                         bool editable = FALSE, bool = TRUE,
                         const QBrush *fill = 0);
-    QRect comboButtonRect(int x, int y, int w, int h) const;
+    QRect comboButtonRect(int x, int y, int w, int h);
-    QRect comboButtonFocusRect(int x, int y, int w, int h) const;
+    QRect comboButtonFocusRect(int x, int y, int w, int h);
    void drawIndicator(QPainter *p, int x, int y ,int w, int h,
                       const QColorGroup &g, int state,
                       bool = FALSE, bool = TRUE);
    QSize indicatorSize() const;
    void drawExclusiveIndicator(QPainter *p, int x, int y ,int w, int h,
                                const QColorGroup &g, bool on,
                                bool = FALSE, bool = TRUE);
    QSize exclusiveIndicatorSize() const;
    void drawPanel(QPainter * p, int x, int y, int w, int h,
                   const QColorGroup &g, bool sunken = FALSE,
                   int = 1, const QBrush * = 0);
    void scrollBarMetrics( const QScrollBar *,
-                           int &, int &, int &, int & ) const;
+                           int &, int &, int &, int & );
    void drawScrollBarControls(QPainter* p, const QScrollBar* sb,
                               int sliderStart, uint controls,
                               uint activeControl);
    QStyle::ScrollControl scrollBarPointOver(const QScrollBar *, int, const QPoint& p);
    void drawTab(QPainter *p, const QTabBar *tabbar, QTab *tab, bool selected);
    void drawSlider(QPainter *p, int x, int y, int w, int h,
                    const QColorGroup &g, Qt::Orientation orientation,
                    bool, bool);
    void drawSliderGroove(QPainter *p, int x, int y, int w, int h,
                          const QColorGroup& g, QCOORD,
                          Qt::Orientation );
    void drawToolBarHandle(QPainter *, const QRect &, Qt::Orientation,
                           bool, const QColorGroup &, bool = FALSE );
    QSize scrollBarExtent() const;
    int buttonDefaultIndicatorWidth() const;
    int buttonMargin() const;
    int sliderThickness() const;
    int sliderLength() const;
    int defaultFrameWidth() const;
    int extraPopupMenuItemWidth( bool checkable, int maxpmw, QMenuItem*, const QFontMetrics& );
    int popupMenuItemHeight( bool checkable, QMenuItem*, const QFontMetrics& );
    void drawPopupMenuItem( QPainter* p, bool checkable, int maxpmw, int tab, QMenuItem* mi,
                                       const QPalette& pal,
                                       bool act, bool enabled, int x, int y, int w, int h);
 protected:
    bool eventFilter(QObject *, QEvent *);
 };
 #endif
 #endif // LIGHTSTYLE_H
author	erik <erik>	2007-01-10 17:24:23 (UTC)
committer	erik <erik>	2007-01-10 17:24:23 (UTC)
commit	e7d3e1d0f3c75979c01ea6373ed3c80d0c986000 (patch) (unidiff)
tree	34a6e8aa3de82f07c0531e59f375da216fbfb97a
parent	51bd5e8d542372ad54898ce642fe9b82b8ba83f3 (diff)
download	opie-e7d3e1d0f3c75979c01ea6373ed3c80d0c986000.zip opie-e7d3e1d0f3c75979c01ea6373ed3c80d0c986000.tar.gz opie-e7d3e1d0f3c75979c01ea6373ed3c80d0c986000.tar.bz2