API docu fixes...

if using \fn infront of a function make sure to name the right function
ljp please see my comment in oticker about constness

18 files changed, 93 insertions, 45 deletions

diff --git a/libopie/colordialog.cpp b/libopie/colordialog.cpp
index 35f15d6..c7421ec 100644
--- a/libopie/colordialog.cpp
+++ b/libopie/colordialog.cpp
@@ -1,858 +1,858 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of OColorDialog class
 **
 ** Created : 990222
 **
 ** Copyright (C) 1999-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the dialogs module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** 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.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** 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/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "colordialog.h"
 
 #include "qpainter.h"
 #include "qlayout.h"
 #include "qlabel.h"
 #include "qpushbutton.h"
 #include "qlineedit.h"
 #include "qimage.h"
 #include "qpixmap.h"
 #include "qdrawutil.h"
 #include "qvalidator.h"
 #include "qdragobject.h"
 #include "qapplication.h"
 #include "qdragobject.h"
 
 static inline void rgb2hsv( QRgb rgb, int&h, int&s, int&v )
 {
     QColor c;
     c.setRgb( rgb );
     c.getHsv(h,s,v);
 }
 
 /*
  * avoid clashes with the original Qt
  */
 namespace {
 
 class QColorPicker : public QFrame
 {
     Q_OBJECT
 public:
     QColorPicker(QWidget* parent=0, const char* name=0);
     ~QColorPicker();
 
 public slots:
     void setCol( int h, int s );
 
 signals:
     void newCol( int h, int s );
 
 protected:
     QSize sizeHint() const;
     QSizePolicy sizePolicy() const;
     void drawContents(QPainter* p);
     void mouseMoveEvent( QMouseEvent * );
     void mousePressEvent( QMouseEvent * );
 
 private:
     int hue;
     int sat;
 
     QPoint colPt();
     int huePt( const QPoint &pt );
     int satPt( const QPoint &pt );
     void setCol( const QPoint &pt );
 
     QPixmap *pix;
 };
 
 static int pWidth = 200;
 static int pHeight = 200;
 
 class QColorLuminancePicker : public QWidget
 {
     Q_OBJECT
 public:
     QColorLuminancePicker(QWidget* parent=0, const char* name=0);
     ~QColorLuminancePicker();
 
 public slots:
     void setCol( int h, int s, int v );
     void setCol( int h, int s );
 
 signals:
     void newHsv( int h, int s, int v );
 
 protected:
 //    QSize sizeHint() const;
 //    QSizePolicy sizePolicy() const;
     void paintEvent( QPaintEvent*);
     void mouseMoveEvent( QMouseEvent * );
     void mousePressEvent( QMouseEvent * );
 
 private:
     enum { foff = 3, coff = 4 }; //frame and contents offset
     int val;
     int hue;
     int sat;
 
     int y2val( int y );
     int val2y( int val );
     void setVal( int v );
 
     QPixmap *pix;
 };
 
 
 int QColorLuminancePicker::y2val( int y )
 {
     int d = height() - 2*coff - 1;
     return 255 - (y - coff)*255/d;
 }
 
 int QColorLuminancePicker::val2y( int v )
 {
     int d = height() - 2*coff - 1;
     return coff + (255-v)*d/255;
 }
 
 QColorLuminancePicker::QColorLuminancePicker(QWidget* parent,
                                                   const char* name)
     :QWidget( parent, name )
 {
     hue = 100; val = 100; sat = 100;
     pix = 0;
     //    setBackgroundMode( NoBackground );
 }
 
 QColorLuminancePicker::~QColorLuminancePicker()
 {
     delete pix;
 }
 
 void QColorLuminancePicker::mouseMoveEvent( QMouseEvent *m )
 {
     setVal( y2val(m->y()) );
 }
 void QColorLuminancePicker::mousePressEvent( QMouseEvent *m )
 {
     setVal( y2val(m->y()) );
 }
 
 void QColorLuminancePicker::setVal( int v )
 {
     if ( val == v )
         return;
     val = QMAX( 0, QMIN(v,255));
     delete pix; pix=0;
     repaint( FALSE ); //###
     emit newHsv( hue, sat, val );
 }
 
 //receives from a hue,sat chooser and relays.
 void QColorLuminancePicker::setCol( int h, int s )
 {
     setCol( h, s, val );
     emit newHsv( h, s, val );
 }
 
 void QColorLuminancePicker::paintEvent( QPaintEvent * )
 {
     int w = width() - 5;
 
     QRect r( 0, foff, w, height() - 2*foff );
     int wi = r.width() - 2;
     int hi = r.height() - 2;
     if ( !pix || pix->height() != hi || pix->width() != wi ) {
         delete pix;
         QImage img( wi, hi, 32 );
         int y;
         for ( y = 0; y < hi; y++ ) {
             QColor c( hue, sat, y2val(y+coff), QColor::Hsv );
             QRgb r = c.rgb();
             int x;
             for ( x = 0; x < wi; x++ )
                 img.setPixel( x, y, r );
         }
         pix = new QPixmap;
         pix->convertFromImage(img);
     }
     QPainter p(this);
     p.drawPixmap( 1, coff, *pix );
     QColorGroup g = colorGroup();
     qDrawShadePanel( &p, r, g, TRUE );
     p.setPen( g.foreground() );
     p.setBrush( g.foreground() );
     QPointArray a;
     int y = val2y(val);
     a.setPoints( 3, w, y, w+5, y+5, w+5, y-5 );
     erase( w, 0, 5, height() );
     p.drawPolygon( a );
 }
 
 void QColorLuminancePicker::setCol( int h, int s , int v )
 {
     val = v;
     hue = h;
     sat = s;
     delete pix; pix=0;
     repaint( FALSE );//####
 }
 
 QPoint QColorPicker::colPt()
 { return QPoint( (360-hue)*(pWidth-1)/360, (255-sat)*(pHeight-1)/255 ); }
 int QColorPicker::huePt( const QPoint &pt )
 { return 360 - pt.x()*360/(pWidth-1); }
 int QColorPicker::satPt( const QPoint &pt )
 { return 255 - pt.y()*255/(pHeight-1) ; }
 void QColorPicker::setCol( const QPoint &pt )
 { setCol( huePt(pt), satPt(pt) ); }
 
 QColorPicker::QColorPicker(QWidget* parent, const char* name )
     : QFrame( parent, name )
 {
     hue = 0; sat = 0;
     setCol( 150, 255 );
 
     QImage img( pWidth, pHeight, 32 );
     int x,y;
     for ( y = 0; y < pHeight; y++ )
         for ( x = 0; x < pWidth; x++ ) {
             QPoint p( x, y );
             img.setPixel( x, y, QColor(huePt(p), satPt(p),
                                        200, QColor::Hsv).rgb() );
         }
     pix = new QPixmap;
     pix->convertFromImage(img);
     setBackgroundMode( NoBackground );
 }
 
 QColorPicker::~QColorPicker()
 {
     delete pix;
 }
 
 QSize QColorPicker::sizeHint() const
 {
     return QSize( pWidth + 2*frameWidth(), pHeight + 2*frameWidth() );
 }
 
 QSizePolicy QColorPicker::sizePolicy() const
 {
     return QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
 }
 
 void QColorPicker::setCol( int h, int s )
 {
     int nhue = QMIN( QMAX(0,h), 360 );
     int nsat = QMIN( QMAX(0,s), 255);
     if ( nhue == hue && nsat == sat )
         return;
     QRect r( colPt(), QSize(20,20) );
     hue = nhue; sat = nsat;
     r = r.unite( QRect( colPt(), QSize(20,20) ) );
     r.moveBy( contentsRect().x()-9, contentsRect().y()-9 );
     //    update( r );
     repaint( r, FALSE );
 }
 
 void QColorPicker::mouseMoveEvent( QMouseEvent *m )
 {
     QPoint p = m->pos() - contentsRect().topLeft();
     setCol( p );
     emit newCol( hue, sat );
 }
 
 void QColorPicker::mousePressEvent( QMouseEvent *m )
 {
     QPoint p = m->pos() - contentsRect().topLeft();
     setCol( p );
     emit newCol( hue, sat );
 }
 
 void QColorPicker::drawContents(QPainter* p)
 {
     QRect r = contentsRect();
 
     p->drawPixmap( r.topLeft(), *pix );
     QPoint pt = colPt() + r.topLeft();
     p->setPen( QPen(black) );
 
     p->fillRect( pt.x()-9, pt.y(), 20, 2, black );
     p->fillRect( pt.x(), pt.y()-9, 2, 20, black );
 
 }
 
 class QColorShowLabel;
 
 
 
 class QColIntValidator: public QIntValidator
 {
 public:
     QColIntValidator( int bottom, int top,
                    QWidget * parent, const char *name = 0 )
         :QIntValidator( bottom, top, parent, name ) {}
 
     QValidator::State validate( QString &, int & ) const;
 };
 
 QValidator::State QColIntValidator::validate( QString &s, int &pos ) const
 {
     State state = QIntValidator::validate(s,pos);
     if ( state == Valid ) {
         long int val = s.toLong();
         // This is not a general solution, assumes that top() > 0 and
         // bottom >= 0
         if ( val < 0 ) {
             s = "0";
             pos = 1;
         } else if ( val > top() ) {
             s.setNum( top() );
             pos = s.length();
         }
     }
     return state;
 }
 
 
 
 class QColNumLineEdit : public QLineEdit
 {
 public:
     QColNumLineEdit( QWidget *parent, const char* name = 0 )
         : QLineEdit( parent, name ) { setMaxLength( 3 );}
     QSize sizeHint() const {
         return QSize( 30, //#####
                      QLineEdit::sizeHint().height() ); }
     void setNum( int i ) {
         QString s;
         s.setNum(i);
         bool block = signalsBlocked();
         blockSignals(TRUE);
         setText( s );
         blockSignals(block);
     }
     int val() const { return text().toInt(); }
 };
 
 
 class QColorShower : public QWidget
 {
     Q_OBJECT
 public:
     QColorShower( QWidget *parent, const char *name = 0 );
 
     //things that don't emit signals
     void setHsv( int h, int s, int v );
 
     int currentAlpha() const { return alphaEd->val(); }
     void setCurrentAlpha( int a ) { alphaEd->setNum( a ); }
     void showAlpha( bool b );
 
 
     QRgb currentColor() const { return curCol; }
 
 public slots:
     void setRgb( QRgb rgb );
 
 signals:
     void newCol( QRgb rgb );
 private slots:
     void rgbEd();
     void hsvEd();
 private:
     void showCurrentColor();
     int hue, sat, val;
     QRgb curCol;
     QColNumLineEdit *hEd;
     QColNumLineEdit *sEd;
     QColNumLineEdit *vEd;
     QColNumLineEdit *rEd;
     QColNumLineEdit *gEd;
     QColNumLineEdit *bEd;
     QColNumLineEdit *alphaEd;
     QLabel *alphaLab;
     QColorShowLabel *lab;
     bool rgbOriginal;
 };
 
 class QColorShowLabel : public QFrame
 {
     Q_OBJECT
 
 public:
     QColorShowLabel( QWidget *parent ) :QFrame( parent ) {
         setFrameStyle( QFrame::Panel|QFrame::Sunken );
         setBackgroundMode( PaletteBackground );
         setAcceptDrops( TRUE );
         mousePressed = FALSE;
     }
     void setColor( QColor c ) { col = c; }
 
 signals:
     void colorDropped( QRgb );
 
 protected:
     void drawContents( QPainter *p );
     void mousePressEvent( QMouseEvent *e );
     void mouseReleaseEvent( QMouseEvent *e );
 
 private:
     QColor col;
     bool mousePressed;
     QPoint pressPos;
 
 };
 
 void QColorShowLabel::drawContents( QPainter *p )
 {
     p->fillRect( contentsRect(), col );
 }
 
 void QColorShower::showAlpha( bool b )
 {
     if ( b ) {
         alphaLab->show();
         alphaEd->show();
     } else {
         alphaLab->hide();
         alphaEd->hide();
     }
 }
 
 void QColorShowLabel::mousePressEvent( QMouseEvent *e )
 {
     mousePressed = TRUE;
     pressPos = e->pos();
 }
 
 void QColorShowLabel::mouseReleaseEvent( QMouseEvent * )
 {
     if ( !mousePressed )
         return;
     mousePressed = FALSE;
 }
 
 QColorShower::QColorShower( QWidget *parent, const char *name )
     :QWidget( parent, name)
 {
     curCol = qRgb( -1, -1, -1 );
     QColIntValidator *val256 = new QColIntValidator( 0, 255, this );
     QColIntValidator *val360 = new QColIntValidator( 0, 360, this );
 
     QGridLayout *gl = new QGridLayout( this, 1, 1, 2 );
     gl->setMargin( 0 );
     lab = new QColorShowLabel( this );
     lab->setMinimumWidth( 60 ); //###
     gl->addMultiCellWidget(lab, 0,-1,0,0);
     connect( lab, SIGNAL( colorDropped( QRgb ) ),
              this, SIGNAL( newCol( QRgb ) ) );
     connect( lab, SIGNAL( colorDropped( QRgb ) ),
              this, SLOT( setRgb( QRgb ) ) );
 
     hEd = new QColNumLineEdit( this );
     hEd->setValidator( val360 );
     QLabel *l = new QLabel( hEd, OColorDialog::tr("Hue:"), this );
     l->setAlignment( AlignRight|AlignVCenter );
     gl->addWidget( l, 0, 1 );
     gl->addWidget( hEd, 0, 2 );
 
     sEd = new QColNumLineEdit( this );
     sEd->setValidator( val256 );
     l = new QLabel( sEd, OColorDialog::tr("Sat:"), this );
     l->setAlignment( AlignRight|AlignVCenter );
     gl->addWidget( l, 1, 1 );
     gl->addWidget( sEd, 1, 2 );
 
     vEd = new QColNumLineEdit( this );
     vEd->setValidator( val256 );
     l = new QLabel( vEd, OColorDialog::tr("Val:"), this );
     l->setAlignment( AlignRight|AlignVCenter );
     gl->addWidget( l, 2, 1 );
     gl->addWidget( vEd, 2, 2 );
 
     rEd = new QColNumLineEdit( this );
     rEd->setValidator( val256 );
     l = new QLabel( rEd, OColorDialog::tr("Red:"), this );
     l->setAlignment( AlignRight|AlignVCenter );
     gl->addWidget( l, 0, 3 );
     gl->addWidget( rEd, 0, 4 );
 
     gEd = new QColNumLineEdit( this );
     gEd->setValidator( val256 );
     l = new QLabel( gEd, OColorDialog::tr("Green:"), this );
     l->setAlignment( AlignRight|AlignVCenter );
     gl->addWidget( l, 1, 3 );
     gl->addWidget( gEd, 1, 4 );
 
     bEd = new QColNumLineEdit( this );
     bEd->setValidator( val256 );
     l = new QLabel( bEd, OColorDialog::tr("Blue:"), this );
     l->setAlignment( AlignRight|AlignVCenter );
     gl->addWidget( l, 2, 3 );
     gl->addWidget( bEd, 2, 4 );
 
     alphaEd = new QColNumLineEdit( this );
     alphaEd->setValidator( val256 );
     alphaLab = new QLabel( alphaEd, OColorDialog::tr("Alpha channel:"), this );
     alphaLab->setAlignment( AlignRight|AlignVCenter );
     gl->addMultiCellWidget( alphaLab, 3, 3, 1, 3 );
     gl->addWidget( alphaEd, 3, 4 );
     alphaEd->hide();
     alphaLab->hide();
 
     connect( hEd, SIGNAL(textChanged(const QString&)), this, SLOT(hsvEd()) );
     connect( sEd, SIGNAL(textChanged(const QString&)), this, SLOT(hsvEd()) );
     connect( vEd, SIGNAL(textChanged(const QString&)), this, SLOT(hsvEd()) );
 
     connect( rEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
     connect( gEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
     connect( bEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
 }
 
 void QColorShower::showCurrentColor()
 {
     lab->setColor( currentColor() );
     lab->repaint(FALSE); //###
 }
 
 void QColorShower::rgbEd()
 {
     rgbOriginal = TRUE;
     curCol = qRgb( rEd->val(), gEd->val(), bEd->val() );
     rgb2hsv(currentColor(), hue, sat, val );
 
     hEd->setNum( hue );
     sEd->setNum( sat );
     vEd->setNum( val );
 
     showCurrentColor();
     emit newCol( currentColor() );
 }
 
 void QColorShower::hsvEd()
 {
     rgbOriginal = FALSE;
     hue = hEd->val();
     sat = sEd->val();
     val = vEd->val();
 
     curCol = QColor( hue, sat, val, QColor::Hsv ).rgb();
 
     rEd->setNum( qRed(currentColor()) );
     gEd->setNum( qGreen(currentColor()) );
     bEd->setNum( qBlue(currentColor()) );
 
     showCurrentColor();
     emit newCol( currentColor() );
 }
 
 void QColorShower::setRgb( QRgb rgb )
 {
     rgbOriginal = TRUE;
     curCol = rgb;
 
     rgb2hsv( currentColor(), hue, sat, val );
 
     hEd->setNum( hue );
     sEd->setNum( sat );
     vEd->setNum( val );
 
     rEd->setNum( qRed(currentColor()) );
     gEd->setNum( qGreen(currentColor()) );
     bEd->setNum( qBlue(currentColor()) );
 
     showCurrentColor();
 }
 
 void QColorShower::setHsv( int h, int s, int v )
 {
     rgbOriginal = FALSE;
     hue = h; val = v; sat = s; //Range check###
     curCol = QColor( hue, sat, val, QColor::Hsv ).rgb();
 
     hEd->setNum( hue );
     sEd->setNum( sat );
     vEd->setNum( val );
 
     rEd->setNum( qRed(currentColor()) );
     gEd->setNum( qGreen(currentColor()) );
     bEd->setNum( qBlue(currentColor()) );
 
 
     showCurrentColor();
 }
 
 }
 
 class OColorDialogPrivate : public QObject
 {
 Q_OBJECT
 public:
     OColorDialogPrivate( OColorDialog *p );
     QRgb currentColor() const { return cs->currentColor(); }
     void setCurrentColor( const QRgb& rgb );
 
     int currentAlpha() const { return cs->currentAlpha(); }
     void setCurrentAlpha( int a ) { cs->setCurrentAlpha( a ); }
     void showAlpha( bool b ) { cs->showAlpha( b ); }
 
 private slots:
     void newHsv( int h, int s, int v );
     void newColorTypedIn( QRgb rgb );
 private:
     QColorPicker *cp;
     QColorLuminancePicker *lp;
     QColorShower *cs;
 };
 
 //sets all widgets to display h,s,v
 void OColorDialogPrivate::newHsv( int h, int s, int v )
 {
     cs->setHsv( h, s, v );
     cp->setCol( h, s );
     lp->setCol( h, s, v );
 }
 
 //sets all widgets to display rgb
 void OColorDialogPrivate::setCurrentColor( const QRgb& rgb )
 {
     cs->setRgb( rgb );
     newColorTypedIn( rgb );
 }
 
 //sets all widgets exept cs to display rgb
 void OColorDialogPrivate::newColorTypedIn( QRgb rgb )
 {
     int h, s, v;
     rgb2hsv(rgb, h, s, v );
     cp->setCol( h, s );
     lp->setCol( h, s, v);
 }
 
 OColorDialogPrivate::OColorDialogPrivate( OColorDialog *dialog ) :
     QObject(dialog)
 {
     int border = 2;
     QVBoxLayout *topLay = new QVBoxLayout( dialog, border, 2 );
 
     QHBoxLayout *pickLay = new QHBoxLayout( topLay );
 
 
     cp = new QColorPicker( dialog );
     cp->setFrameStyle( QFrame::Panel + QFrame::Sunken );
     pickLay->addWidget( cp );
 
     pickLay->addStretch();
 
     lp = new QColorLuminancePicker( dialog );
     lp->setFixedWidth( 20 ); //###
     pickLay->addWidget( lp );
 
     connect( cp, SIGNAL(newCol(int,int)), lp, SLOT(setCol(int,int)) );
     connect( lp, SIGNAL(newHsv(int,int,int)), this, SLOT(newHsv(int,int,int)) );
 
     topLay->addStretch();
 
     cs = new QColorShower( dialog );
     connect( cs, SIGNAL(newCol(QRgb)), this, SLOT(newColorTypedIn(QRgb)));
     topLay->addWidget( cs );
 
 }
 
 
 // BEING REVISED: jo
 /*!
-  \class OColorDialog OColorDialog.h
+  \class ColorDialog ColorDialog.h
   \brief The OColorDialog class provides a dialog widget for specifying colors.
   \ingroup dialogs
 
   The color dialog's function is to allow users to choose colors -
   for instance, you might use this in a drawing program to allow the
   user to set the brush color.
 
   This version of Qt only provides modal color dialogs. The static
   getColor() function shows the dialog and allows the user to specify a color,
   while getRgba() does the same but allows the user to specify a color with an
   alpha channel (transparency) value.
 
   The user can store customCount() different custom colors. The custom
   colors are shared by all color dialogs, and remembered during the
   execution of the program. Use setCustomColor() to set the
   custom colors, and customColor() to get them.
 
   <img src=qcolordlg-m.png> <img src=qcolordlg-w.png>
 */
 
 /*!
   Constructs a default color dialog. Use setColor() for setting an initial value.
 
   \sa getColor()
 */
 
 OColorDialog::OColorDialog(QWidget* parent, const char* name, bool modal) :
     QDialog(parent, name, modal )
 {
     d = new OColorDialogPrivate( this );
 }
 
 
 /*!
   Pops up a modal color dialog letting the user choose a color and returns
   that color. The color is initially set to \a initial. Returns an  \link QColor::isValid() invalid\endlink color if the user cancels
   the dialog. All colors allocated by the dialog will be deallocated
   before this function returns.
 */
 
 QColor OColorDialog::getColor( const QColor& initial, QWidget *parent,
                                const char *name )
 {
     int allocContext = QColor::enterAllocContext();
     OColorDialog *dlg = new OColorDialog( parent, name, TRUE );  //modal
     if ( parent && parent->icon() && !parent->icon()->isNull() )
         dlg->setIcon( *parent->icon() );
     else if ( qApp->mainWidget() && qApp->mainWidget()->icon() && !qApp->mainWidget()->icon()->isNull() )
         dlg->setIcon( *qApp->mainWidget()->icon() );
 
     dlg->setCaption( OColorDialog::tr( "Select color" ) );
     dlg->setColor( initial );
     dlg->showMaximized();
     int resultCode = dlg->exec();
     QColor::leaveAllocContext();
     QColor result;
     if ( resultCode == QDialog::Accepted ) {
         result = dlg->color();
     } else {
         result = initial;
     }
     QColor::destroyAllocContext(allocContext);
     delete dlg;
     return result;
 }
 
 
 /*!
   Pops up a modal color dialog, letting the user choose a color and an
   alpha channel value. The color+alpha is initially set to \a initial.
 
   If \a ok is non-null, \c *ok is set to TRUE if the user clicked OK,
   and FALSE if the user clicked Cancel.
 
   If the user clicks Cancel the \a initial value is returned.
 */
 
 QRgb OColorDialog::getRgba( const QRgb& initial, bool *ok,
                             QWidget *parent, const char* name )
 {
     int allocContext = QColor::enterAllocContext();
     OColorDialog *dlg = new OColorDialog( parent, name, TRUE );  //modal
     dlg->setColor( initial );
     dlg->setSelectedAlpha( qAlpha(initial) );
     dlg->showMaximized();
     int resultCode = dlg->exec();
     QColor::leaveAllocContext();
     QRgb result = initial;
     if ( resultCode == QDialog::Accepted ) {
         QRgb c = dlg->color().rgb();
         int alpha = dlg->selectedAlpha();
         result = qRgba( qRed(c), qGreen(c), qBlue(c), alpha );
     }
     if ( ok )
         *ok = resultCode == QDialog::Accepted;
 
     QColor::destroyAllocContext(allocContext);
     delete dlg;
     return result;
 }
 
 
 
 
 
 /*!
   Returns the color currently selected in the dialog.
 
   \sa setColor()
 */
 
 QColor OColorDialog::color() const
 {
     return QColor(d->currentColor());
 }
 
 
 /*! Destructs the dialog and frees any memory it allocated.
 
 */
 
 OColorDialog::~OColorDialog()
 {
     //d inherits QObject, so it is deleted by Qt.
 }
 
 
 /*!
   Sets the color shown in the dialog to \a c.
 
   \sa color()
 */
 
 void OColorDialog::setColor( const QColor& c )
 {
     d->setCurrentColor( c.rgb() );
 }
 
 
 
 
 /*!
   Sets the initial alpha channel value to \a a, and show the alpha channel
   entry box.
 */
 
 void OColorDialog::setSelectedAlpha( int a )
 {
     d->showAlpha( TRUE );
     d->setCurrentAlpha( a );
 }
 
 
 /*!
   Returns the value selected for the alpha channel.
 */
 
 int OColorDialog::selectedAlpha() const
 {
     return d->currentAlpha();
 }
 
 #include "colordialog.moc"
diff --git a/libopie/colordialog.h b/libopie/colordialog.h
index e9bb7ed..1a6a3fd 100644
--- a/libopie/colordialog.h
+++ b/libopie/colordialog.h
@@ -1,89 +1,89 @@
 /****************************************************************************
 ** $Id$
 **
 ** Definition of OColorDialog class
 **
 ** Created : 990222
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the dialogs module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** 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.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** 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/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #ifndef OColorDialog_H
 #define OColorDialog_H
 
 #ifndef QT_H
 #include <qdialog.h>
 #endif // QT_H
 
 class OColorDialogPrivate;
 
-/**
+/*
  * @class OColorDialog
  * @brief The OColorDialog class is a copy of QColorDialog for use in Opie.
  *
  * OColorDialog is a copy of TrollTech's QColorDialog for use in Opie.  The default
  * build of QT/Embedded used by Opie does not include QColorDialog, so it is provided
  * here.  It is renamed to prevent conflicts in the event the QColorDialog is included
  * at a later date in QP/E.
  *
  * See http://doc.trolltech.com/2.3/qcolordialog.html for complete documentation of
  * QColorDialog.
  */
 class Q_EXPORT OColorDialog : public QDialog
 {
     Q_OBJECT
 
 public:
-    static QColor getColor( const QColor&, QWidget *parent=0, const char* name=0 ); 
+    static QColor getColor( const QColor&, QWidget *parent=0, const char* name=0 );
     static QRgb getRgba( const QRgb&, bool* ok = 0,
                          QWidget *parent=0, const char* name=0 );
 
 private:
     ~OColorDialog();
 
     OColorDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE );
     void setColor( const QColor& );
     QColor color() const;
 
 private:
     void setSelectedAlpha( int );
     int selectedAlpha() const;
 private:
     OColorDialogPrivate *d;
     friend class OColorDialogPrivate;
 
         private:// Disabled copy constructor and operator=
 #if defined(Q_DISABLE_COPY)
     OColorDialog( const OColorDialog & );
     OColorDialog& operator=( const OColorDialog & );
 #endif
 };
 
 #endif
diff --git a/libopie/colorpopupmenu.h b/libopie/colorpopupmenu.h
index 184b132..3e90c5e 100644
--- a/libopie/colorpopupmenu.h
+++ b/libopie/colorpopupmenu.h
@@ -1,254 +1,254 @@
 /*
                             This file is part of the Opie Project
 
                  Copyright (c)  2002 S. Prud'homme <prudhomme@laposte.net>
                                      Dan Williams <williamsdr@acm.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 COLORPOPUPMENU_H
 #define COLORPOPUPMENU_H
 
 #include <qframe.h>
 #include <qpopupmenu.h>
 
 class QWidget;
 class QGridLayout;
 
 /**
  * @class OColorPanelButton
  * @brief The OColorPanelButton class provides a button for color selection.
  *
  * @see OColorPopupMenu
  *
  * The OColorPanelButton class provides a button for color selection.  The button
  * is drawn with the desired color and no border.  This class is used internally
  * by the OColorPopupMenu class to displaying colors in its menu.
  */
 class OColorPanelButton : public QFrame
 {
     Q_OBJECT
 
 public:
 
 /**
  * @fn OColorPanelButton( const QColor& color, QWidget* parent = 0, const char* name = 0 )
  * @brief Object constructor.
  *
  * @param color Desired color.
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  *
  * Constructs a new ColorPanelButton control with parent, name and desired color.
  */
     OColorPanelButton(const QColor& color, QWidget* parent = 0, const char* name = 0);
 
 /**
- * @fn ~ColorPanelButton()
+ * @fn ~OColorPanelButton()
  * @brief Object destructor.
  */
     ~OColorPanelButton();
 
 /**
  * @fn setActive( bool active )
  * @brief Sets button selection state.
  *
  * @param active Boolean indicator of new button state.
  *
  * Changes button selection state.  If button is selected, a highlighted border
  * is drawn.
  */
     void setActive(bool active);
 
 /**
  * @fn enterEvent( QEvent* e )
  * @brief Reimplemented for internal reasons.
  *
  * @param e Event currently being processed.
  *
  * Reimplemented to ensure correct display of button based on whether it is
  * active or not.
  */
     void enterEvent(QEvent* e);
 
 /**
  * @fn leaveEvent( QEvent* e )
  * @brief Reimplemented for internal reasons.
  *
  * @param e Event currently being processed.
  *
  * Reimplemented to ensure correct display of button based on whether it is
  * active or not.
  */
     void leaveEvent(QEvent* e);
 
 /**
- * @fn paintEvent( QEvent* e )
+ * @fn paintEvent( QPaintEvent* e )
  * @brief Reimplemented for internal reasons.
  *
  * @param e Event currently being processed.
- *
+ * @reimp
  * Reimplemented to ensure correct display of button.
  */
     void paintEvent(QPaintEvent* e);
 
 /**
  * @fn mouseReleaseEvent( QMouseEvent* e )
  * @brief Slot executed when button is pressed.
  *
  * @param e Mouse event currently being processed.
  *
  * @see selected()
  *
  * This slot executes when the button has been pressed.  It emits the selected
  * signal as notification that it has been pressed.
  */
     void mouseReleaseEvent(QMouseEvent* e);
 
 signals:
 
 /**
  * @fn selected( const QColor& color )
  * @brief Signal to indicate button has been pressed.
  *
  * @param color Button color.
  *
  * This signal is emitted when the button is pressed.  It provides the color
  * associated to this button.
  */
     void selected(const QColor&);
 
 private:
     QColor m_color;
     bool m_active : 1;
     class ColorPanelButtonPrivate;
     ColorPanelButtonPrivate *d;
 };
 
 /**
  * @class OColorPopupMenu
  * @brief The OColorPopupMenu class provides a small color selection
  *        popup menu.
  *
  * OColorPopupMenu is a derivation of TrollTech's QPopupMenu and provides
  * a small color selection popup menu which can be attached to another control
  * such as a toolbar button of menu item.
  *
  * The popup menu displays 30 default colors available in a grid, and also
  * includes an option at the bottom to display a color selection dialog box for
  * finer color control.
  */
 class OColorPopupMenu : public QPopupMenu
 {
     Q_OBJECT
 
 public:
 
 /**
  * @fn OColorPopupMenu( const QColor& color, QWidget* parent = 0, const char* name = 0 )
  * @brief Object constructor.
  *
  * @param color Initial color selected in menu.
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  *
  * Constructs a new OColorPopupMenu control with parent, name and initial color selected.
  */
     OColorPopupMenu( const QColor& color, QWidget* parent = 0, const char* name = 0 );
 
 /**
  * @fn ~OColorPopupMenu()
  * @brief Object destructor.
  */
     ~OColorPopupMenu();
 
 private:
     class ColorPopupMenuPrivate;
     ColorPopupMenuPrivate *d;
     QColor       m_color;
     QWidget*     colorPanel;
     QGridLayout* colorLayout;
 
 /**
  * @fn addColor( const QColor& color, int row, int col )
  * @brief Adds color selection option to popup menu.
  *
  * @param color Color to be displayed in menu.
  * @param row Row where color is to appear in menu.
  * @param col Column where color is to appear in menu.
  *
  * Adds a color selection option to popup menu.  Used internally when
  * initially constructing the menu control.
  */
     void addColor( const QColor& color, int row, int col );
 
 signals:
 
 /**
  * @fn colorSelected( const QColor& color )
  * @brief Signal to indicate color chosen from the menu.
  *
  * @param color Color selected from the menu.
  *
  * This signal is emitted when a color has been selected either directly from
  * the menu, or chosen from the color selection dialog.
  */
     void colorSelected( const QColor& color );
 
 protected slots:
 
 /**
  * @fn buttonSelected( const QColor& color )
  * @brief Slot to process selected color.
  *
  * @param color Color selected from the menu.
  *
  * @see colorSelected()
  *
  * This slot executes when a color has been selected from the menu.  It performs
  * two functions:
  * - Emit the colorSelected signal with the color selected.
  * - Hide the menu.
  */
     void buttonSelected( const QColor& color );
 
 /**
  * @fn moreColorClicked()
  * @brief Slot to process display color selection dialog.
  *
  * @see colorSelected()
  *
  * This slot executes when the 'More...' option is selected at the bottom of the menu.
  * It performs the following functions:
  * - Constructs and executes a OColorDialog to allow finer color selection.
  * - Emit the colorSelected signal with the color selected.
  * - Hide the menu.
  */
     void moreColorClicked();
 };
 
 #endif // COLORPOPUPMENUANEL_H
diff --git a/libopie/ocheckitem.h b/libopie/ocheckitem.h
index 2387134..82ee3d0 100644
--- a/libopie/ocheckitem.h
+++ b/libopie/ocheckitem.h
@@ -1,53 +1,62 @@
 /**********************************************************************
 ** Copyright (C) 2002 Stefan Eilers (se, eilers.stefan@epost.de)
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU Library 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.
 **********************************************************************/
 #include <qtable.h>
 
 #ifndef CHECKITEM_H__
 #define CHECKITEM_H__
 
 /**
  * This class represents a checkable QTableItem. This can
  * be added to any QTable.
  *
  *
  * @see QTable
  * @see QTableItem
  * @short An checkable QTableItem
  * @version 1.0
  * @author Stefan Eilers ( eilers@handhelds.org )
  */
 
 class OCheckItem : public QTableItem
 {
 public:
+    /** The size of a box currently unused */
     enum Size { BoxSize = 10 };
     OCheckItem( QTable *t, const QString &sortkey );
 
     virtual void setChecked( bool b );
     virtual void toggle();
     bool isChecked() const;
+    /**
+     * @short Set the sort key
+     * @reimp
+     */
     void setKey( const QString &key ) { m_sortKey = key; }
     virtual QString key() const;
 
+    /**
+     * foo
+     * @internal
+     */
     void paint( QPainter *p, const QColorGroup &cg, const QRect &cr, bool selected );
 
     //static const int BoxSize = 10;
 
 private:
     class OCheckItemPrivate;
     OCheckItemPrivate *d;
     bool m_checked: 1;
     QString m_sortKey;
 
 };
 
 #endif
diff --git a/libopie/oclickablelabel.h b/libopie/oclickablelabel.h
index 4b6dcbc..6e7a123 100644
--- a/libopie/oclickablelabel.h
+++ b/libopie/oclickablelabel.h
@@ -1,53 +1,64 @@
 #ifndef CLICKABLELABEL
 #define CLICKABLELABEL
 
 #include <qlabel.h>
 
 /**
  * This class is a special QLabel which can behave
  * as a QPushButton or QToggleButton.
  * The reason to use a clickable is if you want to save space
  * or you want to skip the border of a normal button
  *
  * <pre>
  *  QLabel* lbl = new OClickableLabel( parent, "PushLabel" );
  *  lbl->setPixmap( "config" );
  *  QWhatsThis::add( lbl, tr("Click here to do something") );
  * </pre>
  *
  * @short A Label behaving as button
  * @author Hakan Ardo, Maximillian Reiß ( harlekin@handhelds.org )
  * @see QLabel
  * @see QPushButton
  * @see QToggleButton
  * @version 1.0
  */
 
 class OClickableLabel: public QLabel
 {
   Q_OBJECT
 public:
     OClickableLabel(QWidget* parent = 0, const char* name = 0,
                    WFlags fl = 0);
     void setToggleButton(bool t);
 
  protected:
+    /** @internal */
     void mousePressEvent( QMouseEvent *e );
+    /** @internal */
     void mouseReleaseEvent( QMouseEvent *e );
+    /** @internal */
     void mouseMoveEvent( QMouseEvent *e );
 
  public slots:
     void setOn(bool on);
  signals:
+    /**
+     * emitted when the labels gets clicked
+     */
     void clicked();
+
+    /**
+     * emitted when the labels gets toggled
+     * @param the new new state of the label
+     */
     void toggled(bool on);
  private:
     bool isToggle : 1;
     bool isDown : 1;
     bool textInverted : 1;
 
     void showState(bool on);
     void setInverted(bool on);
 };
 
 #endif
diff --git a/libopie/ocolorbutton.h b/libopie/ocolorbutton.h
index 338e654..7ff9cd2 100644
--- a/libopie/ocolorbutton.h
+++ b/libopie/ocolorbutton.h
@@ -1,66 +1,72 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This library 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 library is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef __OPIE_OCOLORBUTTON_H__
 #define __OPIE_OCOLORBUTTON_H__
 
 #include <qpushbutton.h>
 
 class OColorButtonPrivate;
 class QColor;
 
 /**
  *
  * @short A Button which will show a OColorPopupMenu
  * @author Robert Griebl ( sandman@handhelds.org )
  * @version 1.0
  * @see QPushButton
  */
 class OColorButton : public QPushButton {
         Q_OBJECT
 public:
         OColorButton ( QWidget *parent = 0, const QColor & = black, const char *name = 0 );
         virtual ~OColorButton ( );
 
         QColor color ( ) const;
 
 signals:
+    /**
+     * emitted when a color gets selected
+     */
         void colorSelected ( const QColor & );
 
 public slots:
         virtual void setColor ( const QColor & );
 
 protected slots:
+    /**
+     * @internal
+     */
         virtual void updateColor ( const QColor & );
 
 private:
         OColorButtonPrivate *d;
 };
 
 #endif
 
diff --git a/libopie/odevicebutton.cpp b/libopie/odevicebutton.cpp
index 4b22358..eccb57c 100644
--- a/libopie/odevicebutton.cpp
+++ b/libopie/odevicebutton.cpp
@@ -1,235 +1,235 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qpixmap.h>
 #include <qstring.h>
 
 #include <qpe/qcopenvelope_qws.h>
 #include <opie/odevicebutton.h>
 
 using namespace Opie;
 
 
 class OQCopMessageData {
-        public:
+public:
         QCString m_channel;
         QCString m_message;
         QByteArray m_data;
 };
 
 
-OQCopMessage::OQCopMessage ( ) 
+OQCopMessage::OQCopMessage ( )
         : d ( 0 )
 {
         init ( QCString ( ), QCString ( ), QByteArray ( ));
 }
 
-OQCopMessage::OQCopMessage ( const OQCopMessage &copy ) 
+OQCopMessage::OQCopMessage ( const OQCopMessage &copy )
         : d ( 0 )
 {
         init ( copy. channel ( ), copy. message ( ), copy. data ( ));
 }
 
 OQCopMessage &OQCopMessage::operator = ( const OQCopMessage &assign )
 {
         init ( assign. channel ( ), assign. message ( ), assign. data ( ));
         return *this;
 }
 
-OQCopMessage::OQCopMessage ( const QCString &ch, const QCString &m, const QByteArray &arg ) 
+OQCopMessage::OQCopMessage ( const QCString &ch, const QCString &m, const QByteArray &arg )
         : d ( 0 )
 {
         init ( ch, m, arg );
 }
 
 void OQCopMessage::init ( const QCString &ch, const QCString &m, const QByteArray &arg )
 {
         if ( !d )
                 d = new OQCopMessageData ( );
         d-> m_channel = ch;
         d-> m_message = m;
         d-> m_data = arg;
 }
 
 bool OQCopMessage::send ( )
 {
         if ( d-> m_channel. isEmpty ( ) || d-> m_message. isEmpty ( ) )
                 return false;
 
         QCopEnvelope e ( d-> m_channel, d-> m_message );
-        
+
         if ( d-> m_data. size ( ))
                 e. writeRawBytes ( d-> m_data. data ( ), d-> m_data. size ( ));
 
         return true;
 }
 
 QCString OQCopMessage::channel ( ) const
 {
         return d-> m_channel;
 }
 
 QCString OQCopMessage::message ( ) const
 {
         return d-> m_message;
 }
 
 QByteArray OQCopMessage::data ( ) const
 {
         return d-> m_data;
 }
 
 void OQCopMessage::setChannel ( const QCString &ch )
 {
         d-> m_channel = ch;
 }
 
 void OQCopMessage::setMessage ( const QCString &m )
 {
         d-> m_message = m;
 }
 
 void OQCopMessage::setData ( const QByteArray &data )
 {
         d-> m_data = data;
 }
 
-/*! \class ODeviceButton
-    \brief The ODeviceButton class represents a physical user mappable button on a Qtopia device.
+/*! \class Opie::ODeviceButton
+    \brief The Opie::ODeviceButton class represents a physical user mappable button on a Qtopia device.
 
     This class represents a physical button on a Qtopia device.    A
     device may have "user programmable" buttons.
     The location and number of buttons will vary from device to
     device.    userText() and pixmap() may be used to describe this button
     to the user in help documentation.
 
     \ingroup qtopiaemb
     \internal
 */
 
 ODeviceButton::ODeviceButton()
 {
 }
 
 ODeviceButton::~ODeviceButton()
 {
 }
 
 /*!
  Returns the button's keycode.
  */
 ushort ODeviceButton::keycode() const
 {
     return m_Keycode;
 }
 
 
 /*!
  This function returns a human readable, translated description of the button.
  */
 QString ODeviceButton::userText() const
 {
     return m_UserText;
 }
 
 /*!
  This function returns the pixmap for this button.    If there isn't one
  it will return an empty (null) pixmap.
  */
 QPixmap ODeviceButton::pixmap() const
 {
     return m_Pixmap;
 }
 
 /*!
  This function returns the factory preset (default) action for when this button
  is pressed.    The return value is a legal QCop message.
  */
 OQCopMessage ODeviceButton::factoryPresetPressedAction() const
 {
     return m_FactoryPresetPressedAction;
 }
 
 /*!
  This function returns the user assigned action for when this button is pressed.
  If no action is assigned, factoryPresetAction() is returned.
  */
 OQCopMessage ODeviceButton::pressedAction() const
 {
     if (m_PressedAction.channel().isEmpty())
         return factoryPresetPressedAction();
     return m_PressedAction;
 }
 
 /*!
  This function returns the factory preset (default) action for when this button
  is pressed and held.    The return value is a legal QCop message.
  */
 OQCopMessage ODeviceButton::factoryPresetHeldAction() const
 {
     return m_FactoryPresetHeldAction;
 }
 
 /*!
  This function returns the user assigned action for when this button is pressed
  and held. If no action is assigned, factoryPresetAction() is returned.
  */
 OQCopMessage ODeviceButton::heldAction() const
 {
     if (m_HeldAction.channel().isEmpty())
         return factoryPresetHeldAction();
     return m_HeldAction;
 }
 
 void ODeviceButton::setKeycode(ushort keycode)
 {
     m_Keycode = keycode;
 }
 
 void ODeviceButton::setUserText(const QString& text)
 {
     m_UserText = text;
 }
 
 void ODeviceButton::setPixmap(const QPixmap& picture)
 {
     m_Pixmap = picture;
 }
 
 void ODeviceButton::setFactoryPresetPressedAction(const OQCopMessage& action)
 {
     m_FactoryPresetPressedAction = action;
 }
 
 
 void ODeviceButton::setPressedAction(const OQCopMessage& action)
 {
     m_PressedAction = action;
 }
 
 void ODeviceButton::setFactoryPresetHeldAction(const OQCopMessage& action)
 {
     m_FactoryPresetHeldAction = action;
 }
 
 void ODeviceButton::setHeldAction(const OQCopMessage& action)
 {
     m_HeldAction = action;
 }
diff --git a/libopie/ofileselector.h b/libopie/ofileselector.h
index 06ac806..d06aa0a 100644
--- a/libopie/ofileselector.h
+++ b/libopie/ofileselector.h
@@ -1,311 +1,314 @@
 /*
   This is based on code and ideas of
   L. J. Potter ljp@llornkcor.com
   Thanks a lot
 
 
                =.            This file is part of the OPIE Project
              .=l.            Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This library 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 library is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef opiefileselector_h
 #define opiefileselector_h
 
 #include <qwidget.h>
 #include <qstring.h>
 #include <qpixmap.h>
 #include <qstringlist.h>
 #include <qmap.h>
 #include <qvaluelist.h>
 
 #include <qpe/applnk.h>
 #include <qlistview.h>
 
-/** This is OPIEs FileDialog Widget. You can use it
- *  as a dropin replacement of the fileselector and
- *  or use any of the new features.
- *  This is also a complete FileSave and FileLoad widget
- *  If you look for a Dialog check OFileDialog
- *
- */
+
 class DocLnk;
 class QCheckBox;
 class QComboBox;
 class QPushButton;
 class FileSelector;
 class QGridLayout;
 class QLineEdit;
 class QLabel;
 class QWidgetStack;
 class QHBoxLayout;
 class QVBoxLayout;
 class QPopupMenu;
 class QFileInfo;
 class QHBox;
 //
 
 typedef QMap< QString, QStringList> MimeTypes;
 
+/**
+ *  This is OPIEs FileDialog Widget. You can use it
+ *  as a dropin replacement of the fileselector and
+ *  or use any of the new features.
+ *  This is also a complete FileSave and FileLoad widget
+ *  If you look for a Dialog check OFileDialog
+ *
+ * NOTE THAT the API will change to be more extendable!
+ */
 class OFileSelector : public QWidget {
   Q_OBJECT
  public:
   /**
    *  The mode of the file selector
    *  Either open, save, fileselector or dir browsing mode
    *
    */
   enum Mode {OPEN=1, SAVE=2, FILESELECTOR=4, DIR=8 };
 
   /**
    * Selector. Either NORMAL for the one shipped with
    * libqpe or EXTENDED. for the EXTENDED
    * EXTENDED_ALL also shows 'hidden' files
    */
   enum Selector{NORMAL=0, EXTENDED = 1, EXTENDED_ALL =2 };
 
   /**
    *  This is reserved for futrue views
    */
   enum View { DIRS = 1, FILES = 2, TREE = 4, ICON = 8 };
 
   /**
    *  A c'tor which should be used for advanced mode
    *  @param wid the parent
    *  @param mode the Mode of the Selector
    *  @param selector the current View of the Selector
    *  @param dirName in which dir to start
    *  @param fileName  a proposed filename
    *  @param mimetypes A list of mimetypes \
    *   QString is for a identifier name like "Text files"
    *   the coresponding QStringList is used for the mimetypes
    *   if empty it'll fill the list of mimetypes depending
    *   on the content of the current directory
    */
 
   OFileSelector(QWidget *wid, int mode, int selector,
                 const QString &dirName,
                 const QString &fileName = QString::null,
                 const MimeTypes &mimetypes = MimeTypes() );
 
 
   /**
    * This is a QPE compatible c'tor
    */
   OFileSelector(const QString &mimeFilter, QWidget *parent,
                 const char *name, bool newVisible = TRUE,
                 bool closeVisible = FALSE );
 
   ~OFileSelector();
 
   // currently only for the FILESELECTOR Mode
   /**
    */
   void setNewVisible( bool /*b*/ );
   void setCloseVisible(bool /*b*/ );
 
   // end file selector mode
   // deprecated
   void reread();
   // make sure not to leak please
   const DocLnk *selected();
   // end deprecated
 
   bool isToolbarVisible() const { return m_shTool;  };
   bool isPermissionBarVisible() const {  return m_shPerm; };
   bool isLineEditVisible()const { return m_shLne; };
   bool isChooserVisible( )const { return m_shChooser; };
   bool isYesCancelVisible()const { return m_shYesNo;  };
   void setYesCancelVisible( bool show );
   void setToolbarVisible( bool show );
   void setPermissionBarVisible( bool show );
   void setLineEditVisible(bool show) ;
   void setChooserVisible( bool chooser );
 
   QCheckBox* permissionCheckbox();
   bool setPermission() const;
   void setPermissionChecked( bool check );
 
   void setMode( int );
 
   bool showDirs()const { return m_dir; }
   void setShowDirs(bool );
 
   const QListView* listView() { return m_View; };
 
   bool isCaseSensetive()const {  return m_case; }
   void setCaseSensetive(bool caSe );
 
   bool showFiles()const { return m_files; };
   void setShowFiles(bool );
   bool cd(const QString &path );
 
 
   int mode()const { return m_mode;  };
   int selector()const { return m_selector; };
   void setSelector( int );
 
   bool showPopup()const { return m_showPopup; };
   void setShowPopup( bool pop ) { m_showPopup = pop; };
   void setPopupMenu( QPopupMenu * );
 
   //  void updateLay();
 
   void reparse(); // re reads the dir
 
   QString selectedName( )const;
   QStringList selectedNames()const;
 
   QString selectedPath() const;
   QStringList selectedPaths() const;
 
   QString directory()const;
   int fileCount() const;
 
   /* the user needs to delete it */
   DocLnk selectedDocument()const;
   /* the user needs to delete it */
   QValueList<DocLnk> selectedDocuments()const;
 
  signals:
   void fileSelected( const DocLnk & );
   void fileSelected( const QString & );
   void dirSelected(const QString &dir );
   void closeMe();
   void ok();
   void cancel();
   void contextMenu();
 
  private slots:
    void slotTest() { qWarning("slotTest" ); setLineEditVisible(false );  };
   void slotOk();
   void slotCancel();
   void slotViewCheck(const QString & );
   void slotMimeCheck(const QString & );
   void slotLocationActivated(const QString & );
   void slotInsertLocationPath(const QString &, int);
   void locationComboChanged();
 
  private:
   void init();
   void updateMimes();
 
  protected:
 
  private:
   int m_mode, m_selector;
   QComboBox *m_location, *m_mimeCheck, *m_viewCheck;
   QPushButton *m_homeButton, *m_docButton, *m_hideButton, *m_ok, *m_cancel;
   QPushButton  *m_reread, *m_up, *m_new, *m_close;
   QListView *m_View;
   QCheckBox *m_checkPerm;
   QWidget *m_pseudo;
   QVBoxLayout *m_pseudoLayout;
 
   QString m_currentDir;
   QString m_name;
 //  QStringList m_mimetypes;
   QMap<QString, QStringList> m_mimetypes;
 
   FileSelector *m_select;
   QWidgetStack *m_stack;
   QVBoxLayout *m_lay;
   QGridLayout *m_Oselector;
 
   QHBox *m_boxToolbar;
   QHBox *m_boxOk; // (no layout anymore) wait
   QHBox *m_boxName; // (no Layout anymore) wait
   QHBox *m_boxView;
 
   QPopupMenu *m_custom;
 
   QLineEdit *m_edit;
   QLabel *m_fnLabel;
 
   bool m_shClose     : 1;
   bool m_shNew       : 1;
   bool m_shTool      : 1;
   bool m_shPerm      : 1;
   bool m_shLne       : 1;
   bool m_shChooser   : 1;
   bool m_shYesNo     : 1;
   bool m_boCheckPerm : 1;
   bool m_autoMime    : 1;
   bool m_case        : 1;
   bool m_dir         : 1;
   bool m_files       : 1;
   bool m_showPopup   : 1;
 
   void initVars();
   virtual void addFile(const QString &mime, QFileInfo *info, bool symlink = FALSE );
   virtual void addDir( const QString &mime, QFileInfo *info , bool symlink = FALSE );
   virtual void addSymlink(const QString &, QFileInfo *, bool = FALSE ){};
   void delItems();
   void initializeName();
   void initializeYes();
   void initializeChooser();
   void initializeListView();
   void initializePerm();
   void initPics();
   bool compliesMime(const QString &path,
                     const QString &mime);
   bool compliesMime(const QString& mime );
     /**
      * Updates the QComboBox with the current mimetypes
      */
   void updateMimeCheck();
 
     /**
      * Returns the current mimetype
      */
   QString currentMimeType()const;
   class OFileSelectorPrivate;
   OFileSelectorPrivate *d;
   static QMap<QString,QPixmap> *m_pixmaps;
 
 private slots:
    void slotFileSelected(const QString & ); // not really meant to be a slot
    void slotFileBridgeSelected( const DocLnk & );
    virtual void slotSelectionChanged();
    virtual void slotCurrentChanged(QListViewItem* );
    virtual void slotClicked( int, QListViewItem *item, const QPoint &, int);
    virtual void slotRightButton(int, QListViewItem *, const QPoint &, int );
    virtual void slotContextMenu( QListViewItem *item);
    // listview above
    // popup below
    virtual void slotChangedDir();
    virtual void slotOpen();
    virtual void slotRescan();
    virtual void slotRename();
    virtual void slotDelete();
    virtual void cdUP();
    virtual void slotHome();
    virtual void slotDoc();
    virtual void slotNavigate( );
 };
 
 
 #endif
 
diff --git a/libopie/ofontselector.h b/libopie/ofontselector.h
index 95ffd04..b819c45 100644
--- a/libopie/ofontselector.h
+++ b/libopie/ofontselector.h
@@ -1,93 +1,96 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This library 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 library is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef OPIE_FONTSELECTOR_H__
 #define OPIE_FONTSELECTOR_H__
 
 #include <qwidget.h>
 
 class QListBox;
 class OFontSelectorPrivate;
 
 /**
  * This class lets you chose a Font out of a list of Fonts.
  * It can show a preview too. This selector will use all available
  * fonts
  *
  *
  * @short A widget to select a font
  * @see QWidget
  * @see QFont
  * @author Rober Griebl
  */
 class OFontSelector : public QWidget
 {
     Q_OBJECT
 
 public:
     OFontSelector ( bool withpreview, QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     virtual ~OFontSelector ( );
 
         bool selectedFont ( QString &family, QString &style, int &size );
         bool selectedFont ( QString &family, QString &style, int &size, QString &charset );
 
         QFont selectedFont ( );
 
         bool setSelectedFont ( const QFont & );
         bool setSelectedFont ( const QString &family, const QString &style, int size, const QString &charset = 0 );
 
         QString fontFamily ( ) const;
         QString fontStyle ( ) const;
         int fontSize ( ) const;
         QString fontCharSet ( ) const;
 
 signals:
         /**
          * This signal gets emitted when a font got chosen
          */
         void fontSelected ( const QFont & );
 
 protected slots:
+    /** @internal */
     virtual void fontFamilyClicked ( int );
+    /** @internal */
     virtual void fontStyleClicked ( int );
+    /** @internal */
     virtual void fontSizeClicked ( int );
 
 protected:
         virtual void resizeEvent ( QResizeEvent *re );
 
 private:
         void loadFonts ( QListBox * );
 
     void changeFont ( );
 
 private:
         OFontSelectorPrivate *d;
 };
 
 #endif
 
diff --git a/libopie/oprocess.h b/libopie/oprocess.h
index bf5fe0e..f2853b0 100644
--- a/libopie/oprocess.h
+++ b/libopie/oprocess.h
@@ -1,747 +1,753 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 //
 //  KPROCESS -- A class for handling child processes in KDE without
 //  having to take care of Un*x specific implementation details
 //
 //  version 0.3.1, Jan 8th 1998
 //
 //  (C) Christian Czezatke
 //  e9025461@student.tuwien.ac.at
 //  Ported by Holger Freyther to the Open Palmtop Integrated Environment
 //
 
 #ifndef __kprocess_h__
 #define __kprocess_h__
 
 #include <sys/types.h> // for pid_t
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
 #include <qvaluelist.h>
 #include <qcstring.h>
 #include <qobject.h>
 
 class QSocketNotifier;
 class OProcessPrivate;
 
 /**
  * Child process invocation, monitoring and control.
  *
  * @sect General usage and features
  *
- *This class allows a KDE application to start child processes without having
+ *This class allows a KDE and OPIE application to start child processes without having
  *to worry about UN*X signal handling issues and zombie process reaping.
  *
  *@see KProcIO
  *
  *Basically, this class distinguishes three different ways of running
  *child processes:
  *
  *@li  OProcess::DontCare -- The child process is invoked and both the child
  *process and the parent process continue concurrently.
  *
  *Starting a  DontCare child process means that the application is
  *not interested in any notification to determine whether the
  *child process has already exited or not.
  *
  *@li  OProcess::NotifyOnExit -- The child process is invoked and both the
  *child and the parent process run concurrently.
  *
  *When the child process exits, the OProcess instance
  *corresponding to it emits the Qt signal @ref processExited().
  *
  *Since this signal is @em not emitted from within a UN*X
  *signal handler, arbitrary function calls can be made.
  *
  *Be aware: When the OProcess objects gets destructed, the child
  *process will be killed if it is still running!
  *This means in particular, that you cannot use a OProcess on the stack
  *with OProcess::NotifyOnExit.
  *
  *@li  OProcess::Block -- The child process starts and the parent process
  *is suspended until the child process exits. (@em Really not recommended
  *for programs with a GUI.)
  *
  *OProcess also provides several functions for determining the exit status
  *and the pid of the child process it represents.
  *
  *Furthermore it is possible to supply command-line arguments to the process
  *in a clean fashion (no null -- terminated stringlists and such...)
  *
  *A small usage example:
  *<pre>
  *OProcess *proc = new OProcess;
  *
  **proc << "my_executable";
  **proc << "These" << "are" << "the" << "command" << "line" << "args";
  *QApplication::connect(proc, SIGNAL(processExited(OProcess *)),
  *                      pointer_to_my_object, SLOT(my_objects_slot(OProcess *)));
  *proc->start();
  *</pre>
  *
  *This will start "my_executable" with the commandline arguments "These"...
  *
  *When the child process exits, the respective Qt signal will be emitted.
  *
  *@sect Communication with the child process
  *
  *OProcess supports communication with the child process through
  *stdin/stdout/stderr.
  *
  *The following functions are provided for getting data from the child
  *process or sending data to the child's stdin (For more information,
  *have a look at the documentation of each function):
  *
  *@li bool @ref writeStdin(char  *buffer, int  buflen);
  *@li  -- Transmit data to the child process's stdin.
  *
  *@li bool @ref closeStdin();
  *@li -- Closes the child process's stdin (which causes it to see an  feof(stdin)).
  *Returns false if you try to close stdin for a process that has been started
  *without a communication channel to stdin.
  *
  *@li bool @ref closeStdout();
  *@li -- Closes the child process's stdout.
  *Returns false if you try to close stdout for a process that has been started
  *without a communication channel to stdout.
  *
  *@li bool @ref closeStderr();
  *@li -- Closes the child process's stderr.
  *Returns false if you try to close stderr for a process that has been started
  *without a communication channel to stderr.
  *
  *
  *@sect QT signals:
  *
  *@li void @ref receivedStdout(OProcess  *proc, char  *buffer, int  buflen);
  *@li  void @ref receivedStderr(OProcess  *proc, char  *buffer, int  buflen);
  *@li  -- Indicates that new data has arrived from either the
  *child process's stdout or stderr.
  *
  *@li  void @ref wroteStdin(OProcess  *proc);
  *@li  -- Indicates that all data that has been sent to the child process
  *by a prior call to @ref writeStdin() has actually been transmitted to the
  *client .
  *
  *@author Christian Czezakte e9025461@student.tuwien.ac.at
  *
  *
  **/
 class OProcess : public QObject
 {
   Q_OBJECT
 
 public:
 
   /**
    * Modes in which the communication channel can be opened.
    *
    * If communication for more than one channel is required,
    * the values have to be or'ed together, for example to get
    * communication with stdout as well as with stdin, you would
    * specify @p Stdin @p | @p Stdout
    *
    * If @p NoRead is specified in conjunction with @p Stdout,
    * no data is actually read from @p Stdout but only
    * the signal @ref childOutput(int fd) is emitted.
    */
   enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
                                            AllOutput = 6, All = 7,
                                            NoRead };
 
   /**
    * Run-modes for a child process.
    */
   enum RunMode {
       /**
        * The application does not receive notifications from the subprocess when
        * it is finished or aborted.
        */
        DontCare,
        /**
         * The application is notified when the subprocess dies.
         */
        NotifyOnExit,
        /**
         * The application is suspended until the started process is finished.
         */
        Block };
 
   /**
    * Constructor
    */
   OProcess(QObject *parent = 0, const char *name = 0);
+  /**
+   * Constructor
+   */
   OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
+  /**
+   * Constructor
+   */
   OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0);
 
   /**
    *Destructor:
    *
    *  If the process is running when the destructor for this class
    *  is called, the child process is killed with a SIGKILL, but
    *  only if the run mode is not of type @p DontCare.
    *  Processes started as @p DontCare keep running anyway.
   */
   virtual ~OProcess();
 
   /**
    @deprecated
 
          The use of this function is now deprecated. -- Please use the
          "operator<<" instead of "setExecutable".
 
          Sets the executable to be started with this OProcess object.
          Returns false if the process is currently running (in that
          case the executable remains unchanged.)
 
          @see operator<<
 
   */
   bool setExecutable(const QString& proc);
 
 
   /**
    * Sets the executable and the command line argument list for this process.
    *
    * For example, doing an "ls -l /usr/local/bin" can be achieved by:
    *  <pre>
    *  OProcess p;
    *  ...
    *  p << "ls" << "-l" << "/usr/local/bin"
    *  </pre>
    *
    **/
   OProcess &operator<<(const QString& arg);
   /**
    * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
    */
   OProcess &operator<<(const char * arg);
   /**
    * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
    */
   OProcess &operator<<(const QCString & arg);
 
   /**
    * Sets the executable and the command line argument list for this process,
    * in a single method call, or add a list of arguments.
    **/
   OProcess &operator<<(const QStringList& args);
 
   /**
    * Clear a command line argument list that has been set by using
    * the "operator<<".
   */
   void clearArguments();
 
   /**
    *  Starts the process.
    *  For a detailed description of the
    *  various run modes and communication semantics, have a look at the
    *  general description of the OProcess class.
    *
    *  The following problems could cause this function to
    *    return false:
    *
    *  @li The process is already running.
    *  @li The command line argument list is empty.
    *  @li The starting of the process failed (could not fork).
    *  @li The executable was not found.
    *
    *  @param comm  Specifies which communication links should be
    *  established to the child process (stdin/stdout/stderr). By default,
    *  no communication takes place and the respective communication
    *  signals will never get emitted.
    *
    *  @return true on success, false on error
    *  (see above for error conditions)
    **/
   virtual bool start(RunMode  runmode = NotifyOnExit,
           Communication comm = NoCommunication);
 
   /**
    * Stop the process (by sending it a signal).
    *
            * @param signoThe signal to send. The default is SIGTERM.
    * @return @p true if the signal was delivered successfully.
   */
   virtual bool kill(int signo = SIGTERM);
 
   /**
      @return @p true if the process is (still) considered to be running
   */
   bool isRunning() const;
 
   /** Returns the process id of the process.
    *
    * If it is called after
    * the process has exited, it returns the process id of the last
    *  child process that was created by this instance of OProcess.
    *
    *  Calling it before any child process has been started by this
    *  OProcess instance causes pid() to return 0.
    **/
   pid_t pid() const;
 
   /**
    * Use pid().
    * @deprecated
    */
   pid_t getPid() const { return pid(); }
 
   /**
    * Suspend processing of data from stdout of the child process.
    */
   void suspend();
 
   /**
    * Resume processing of data from stdout of the child process.
    */
   void resume();
 
   /**
    * @return @p true if the process has already finished and has exited
    *  "voluntarily", ie: it has not been killed by a signal.
    *
    * Note that you should check @ref OProcess::exitStatus() to determine
    * whether the process completed its task successful or not.
    */
   bool normalExit() const;
 
   /**
    * Returns the exit status of the process.
    *
    * Please use
    * @ref OProcess::normalExit() to check whether the process has exited
    * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
    * this function because if the process did not exit normally,
    * it does not have a valid exit status.
   */
   int  exitStatus() const;
 
 
   /**
            * Transmit data to the child process's stdin.
    *
    * OProcess::writeStdin may return false in the following cases:
    *
    *     @li The process is not currently running.
    *
    *     @li Communication to stdin has not been requested in the @ref start() call.
    *
    *     @li Transmission of data to the child process by a previous call to
    * @ref writeStdin() is still in progress.
    *
    * Please note that the data is sent to the client asynchronously,
    * so when this function returns, the data might not have been
    * processed by the child process.
    *
    * If all the data has been sent to the client, the signal
    * @ref wroteStdin() will be emitted.
    *
    * Please note that you must not free "buffer" or call @ref writeStdin()
    * again until either a @ref wroteStdin() signal indicates that the
    * data has been sent or a @ref processHasExited() signal shows that
    * the child process is no longer alive...
    **/
   bool writeStdin(const char *buffer, int buflen);
 
   void flushStdin();
 
   /**
    * This causes the stdin file descriptor of the child process to be
    * closed indicating an "EOF" to the child.
    *
    * @return @p false if no communication to the process's stdin
    *  had been specified in the call to @ref start().
   */
   bool closeStdin();
 
   /**
    * This causes the stdout file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stdout
    *  had been specified in the call to @ref start().
   */
   bool closeStdout();
 
   /**
    * This causes the stderr file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stderr
    *  had been specified in the call to @ref start().
   */
   bool closeStderr();
 
   /**
    * Lets you see what your arguments are for debugging.
    */
 
   const QValueList<QCString> &args() { return arguments; }
 
   /**
    * Controls whether the started process should drop any
    * setuid/segid privileges or whether it should keep them
    *
    * The default is @p false : drop privileges
    */
   void setRunPrivileged(bool keepPrivileges);
 
   /**
    * Returns whether the started process will drop any
    * setuid/segid privileges or whether it will keep them
    */
   bool runPrivileged() const;
-  
+
   /**
    * Modifies the environment of the process to be started.
    * This function must be called before starting the process.
    */
   void setEnvironment(const QString &name, const QString &value);
 
   /**
-   * Changes the current working directory (CWD) of the process 
+   * Changes the current working directory (CWD) of the process
    * to be started.
    * This function must be called before starting the process.
    */
   void setWorkingDirectory(const QString &dir);
 
   /**
    * Specify whether to start the command via a shell or directly.
    * The default is to start the command directly.
    * If @p useShell is true @p shell will be used as shell, or
    * if shell is empty, the standard shell is used.
    * @p quote A flag indicating whether to quote the arguments.
    *
    * When using a shell, the caller should make sure that all filenames etc.
    * are properly quoted when passed as argument.
    * @see quote()
    */
   void setUseShell(bool useShell, const char *shell = 0);
 
   /**
    * This function can be used to quote an argument string such that
    * the shell processes it properly. This is e. g. necessary for
    * user-provided file names which may contain spaces or quotes.
    * It also prevents expansion of wild cards and environment variables.
    */
   static QString quote(const QString &arg);
 
   /**
    * Detaches OProcess from child process. All communication is closed.
    * No exit notification is emitted any more for the child process.
    * Deleting the OProcess will no longer kill the child process.
    * Note that the current process remains the parent process of the
    * child process.
    */
-  void detach(); 
+  void detach();
 
 
 
 signals:
 
   /**
    * Emitted after the process has terminated when
    * the process was run in the @p NotifyOnExit  (==default option to
    * @ref start()) or the @ref Block mode.
    **/
   void processExited(OProcess *proc);
 
 
   /**
    * Emitted, when output from the child process has
    * been received on stdout.
    *
    *  To actually get
    * these signals, the respective communication link (stdout/stderr)
    * has to be turned on in @ref start().
    *
    * @param buffer The data received.
    * @param buflen The number of bytes that are available.
    *
    * You should copy the information contained in @p buffer to your private
    * data structures before returning from this slot.
    **/
   void receivedStdout(OProcess *proc, char *buffer, int buflen);
 
   /**
    * Emitted when output from the child process has
    * been received on stdout.
    *
-   * To actually get these signals, the respective communications link 
-   * (stdout/stderr) has to be turned on in @ref start() and the 
+   * To actually get these signals, the respective communications link
+   * (stdout/stderr) has to be turned on in @ref start() and the
    * @p NoRead flag should have been passed.
    *
    * You will need to explicitly call resume() after your call to start()
    * to begin processing data from the child process's stdout.  This is
    * to ensure that this signal is not emitted when no one is connected
    * to it, otherwise this signal will not be emitted.
-   * 
+   *
    * The data still has to be read from file descriptor @p fd.
    **/
   void receivedStdout(int fd, int &len);
 
 
   /**
    * Emitted, when output from the child process has
    * been received on stderr.
    * To actually get
    * these signals, the respective communication link (stdout/stderr)
    * has to be turned on in @ref start().
    *
    * @param buffer The data received.
    * @param buflen The number of bytes that are available.
    *
    * You should copy the information contained in @p buffer to your private
    * data structures before returning from this slot.
   */
   void receivedStderr(OProcess *proc, char *buffer, int buflen);
 
   /**
    * Emitted after all the data that has been
    * specified by a prior call to @ref writeStdin() has actually been
    * written to the child process.
    **/
   void wroteStdin(OProcess *proc);
 
 
 protected slots:
 
  /**
   * This slot gets activated when data from the child's stdout arrives.
   * It usually calls "childOutput"
   */
   void slotChildOutput(int fdno);
 
  /**
   * This slot gets activated when data from the child's stderr arrives.
   * It usually calls "childError"
   */
   void slotChildError(int fdno);
   /*
         Slot functions for capturing stdout and stderr of the child
   */
 
   /**
    * Called when another bulk of data can be sent to the child's
    * stdin. If there is no more data to be sent to stdin currently
    * available, this function must disable the QSocketNotifier "innot".
    */
   void slotSendData(int dummy);
 
 protected:
 
   /**
-   * Sets up the environment according to the data passed via 
+   * Sets up the environment according to the data passed via
    * setEnvironment(...)
    */
   void setupEnvironment();
 
   /**
    * The list of the process' command line arguments. The first entry
    * in this list is the executable itself.
    */
   QValueList<QCString> arguments;
   /**
    * How to run the process (Block, NotifyOnExit, DontCare). You should
    *  not modify this data member directly from derived classes.
    */
   RunMode run_mode;
   /**
    * true if the process is currently running. You should not
    * modify this data member directly from derived classes. For
    * reading the value of this data member, please use "isRunning()"
    * since "runs" will probably be made private in later versions
    * of OProcess.
    */
   bool runs;
 
   /**
    * The PID of the currently running process (see "getPid()").
    * You should not modify this data member in derived classes.
    * Please use "getPid()" instead of directly accessing this
    * member function since it will probably be made private in
    * later versions of OProcess.
    */
   pid_t pid_;
 
   /**
    * The process' exit status as returned by "waitpid". You should not
    * modify the value of this data member from derived classes. You should
    * rather use @ref exitStatus than accessing this data member directly
    * since it will probably be made private in further versions of
    * OProcess.
    */
   int status;
 
 
   /**
    * See setRunPrivileged()
    */
   bool keepPrivs;
 
   /*
         Functions for setting up the sockets for communication.
         setupCommunication
         -- is called from "start" before "fork"ing.
         commSetupDoneP
         -- completes communication socket setup in the parent
         commSetupDoneC
         -- completes communication setup in the child process
         commClose
         -- frees all allocated communication resources in the parent
         after the process has exited
   */
 
   /**
    * This function is called from "OProcess::start" right before a "fork" takes
    * place. According to
    * the "comm" parameter this function has to initialize the "in", "out" and
    * "err" data member of OProcess.
    *
    * This function should return 0 if setting the needed communication channels
    * was successful.
    *
    * The default implementation is to create UNIX STREAM sockets for the communication,
    * but you could overload this function and establish a TCP/IP communication for
    * network communication, for example.
    */
   virtual int setupCommunication(Communication comm);
 
   /**
    * Called right after a (successful) fork on the parent side. This function
    * will usually do some communications cleanup, like closing the reading end
    * of the "stdin" communication channel.
    *
    * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and
    * "errnot" and connect their Qt slots to the respective OProcess member functions.
    *
    * For a more detailed explanation, it is best to have a look at the default
    * implementation of "setupCommunication" in kprocess.cpp.
    */
   virtual int commSetupDoneP();
 
   /**
    * Called right after a (successful) fork, but before an "exec" on the child
    * process' side. It usually just closes the unused communication ends of
    * "in", "out" and "err" (like the writing end of the "in" communication
    * channel.
    */
   virtual int commSetupDoneC();
 
 
   /**
    * Immediately called after a process has exited. This function normally
    * calls commClose to close all open communication channels to this
    * process and emits the "processExited" signal (if the process was
    * not running in the "DontCare" mode).
    */
   virtual void processHasExited(int state);
 
   /**
    * Should clean up the communication links to the child after it has
    * exited. Should be called from "processHasExited".
    */
   virtual void commClose();
 
 
   /**
    * the socket descriptors for stdin/stdout/stderr.
    */
   int out[2];
   int in[2];
   int err[2];
 
   /**
    * The socket notifiers for the above socket descriptors.
    */
   QSocketNotifier *innot;
   QSocketNotifier *outnot;
   QSocketNotifier *errnot;
 
   /**
    * Lists the communication links that are activated for the child
    * process.  Should not be modified from derived classes.
    */
   Communication communication;
 
   /**
    * Called by "slotChildOutput" this function copies data arriving from the
    * child process's stdout to the respective buffer and emits the signal
    * "@ref receivedStderr".
    */
   int childOutput(int fdno);
 
   /**
    * Called by "slotChildOutput" this function copies data arriving from the
    * child process's stdout to the respective buffer and emits the signal
    * "@ref receivedStderr"
    */
   int childError(int fdno);
 
   // information about the data that has to be sent to the child:
 
   const char *input_data;  // the buffer holding the data
   int input_sent;    // # of bytes already transmitted
   int input_total;   // total length of input_data
 
   /**
    * @ref OProcessController is a friend of OProcess because it has to have
    * access to various data members.
    */
   friend class OProcessController;
 
 
 private:
   /**
-   * Searches for a valid shell. 
+   * Searches for a valid shell.
    * Here is the algorithm used for finding an executable shell:
    *
    *    @li Try the executable pointed to by the "SHELL" environment
    *    variable with white spaces stripped off
    *
    *    @li If your process runs with uid != euid or gid != egid, a shell
    *    not listed in /etc/shells will not used.
    *
    *    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
    */
   QCString searchShell();
 
   /**
    * Used by @ref searchShell in order to find out whether the shell found
    * is actually executable at all.
    */
   bool isExecutable(const QCString &filename);
 
   // Disallow assignment and copy-construction
   OProcess( const OProcess& );
   OProcess& operator= ( const OProcess& );
 
 private:
   void init ( );
 
   OProcessPrivate *d;
 };
 
 
 
 #endif
 
diff --git a/libopie/orecurrancewidget.h b/libopie/orecurrancewidget.h
index af87ce9..a5d6489 100644
--- a/libopie/orecurrancewidget.h
+++ b/libopie/orecurrancewidget.h
@@ -1,84 +1,90 @@
 /*
  * GPL and based on the widget from TT
  */
 
 #ifndef OPIE_RECURRANCE_WIDGET_H
 #define OPIE_RECURRANCE_WIDGET_H
 
 #include <qlist.h>
 #include <qtoolbutton.h>
 #include <qcheckbox.h>
 #include <qdatetime.h>
 #include <qbuttongroup.h>
 
 #include <qpe/datebookmonth.h>
 
 #include "orecurrancebase.h"
 #include <opie/orecur.h>
 
 // FIXME spelling!!!! -zecke
 // FIXME spelling filenames
 
 /**
  * A widget to let the user select rules for recurrences.
  * This widget can take care of weekly, monthly, daily and yearly recurrence
  * It is used inside todolist and datebook.
  *
  *
  * @short Widget of selecting Recurrance
  * @author Trolltech, Holger Freyther
  * @version 0.9
  */
 class ORecurranceWidget : public ORecurranceBase {
     Q_OBJECT
 public:
     ORecurranceWidget( bool startOnMonday,
                        const QDate& start, QWidget* parent = 0,
                        const char* name = 0,  bool modal = TRUE,
                        WFlags fl = 0 );
     ORecurranceWidget( bool startOnMonday,
                        const ORecur& rp, const QDate& start,
                        QWidget* parent = 0, const char* name =0,
                        bool modal = TRUE, WFlags = 0 );
     ~ORecurranceWidget();
     ORecur recurrence()const;
     QDate endDate()const;
 
 public slots:
     void slotSetRType( int );
+    /**
+     * set the new end date
+     */
     void endDateChanged( int, int, int );
+    /**
+     * enable/disable end date
+     */
     void slotNoEnd( bool unused );
     void setStartDate( const QDate& );
     void setRecurrence( const ORecur& recur, const QDate& start );
     void setRecurrence( const ORecur& recur );
 
 private slots:
     void setupRepeatLabel( const QString& );
     void setupRepeatLabel( int );
     void slotWeekLabel();
     void slotMonthLabel( int );
     void slotChangeStartOfWeek( bool onMonday );
 
 private:
     void setupNone();
     void setupDaily();
     void setupWeekly();
     void setupMonthly();
     void setupYearly();
 
     enum repeatButtons { None, Day, Week, Month, Year };
     void init();
     void hideExtras();
     void showRepeatStuff();
 
     QList<QToolButton> listRTypeButtons;
     QList<QToolButton> listExtra;
     QDate start;    // only used in one spot...
     QDate end;
     repeatButtons currInterval;
     bool startWeekOnMonday : 1;
     DateBookMonth *repeatPicker;
 
 };
 
 #endif
diff --git a/libopie/otabbar.h b/libopie/otabbar.h
index c413611..0b353e2 100644
--- a/libopie/otabbar.h
+++ b/libopie/otabbar.h
@@ -1,76 +1,76 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Dan Williams <williamsdr@acm.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 OTABBAR_H
 #define OTABBAR_H
 
 #include <qtabbar.h>
 
 /**
  * @class OTabBar
  * @brief The OTabBar class is a derivative of QTabBar.
  *
  * OTabBar is a derivation of TrollTech's QTabBar which provides
  * a row of tabs for selection.  The only difference between this
  * class and QTabBar is that there is no dotted line box around
  * the label of the tab with the current focus.
  */
 class OTabBar : public QTabBar
 {
     Q_OBJECT
 
 public:
 /**
  * @fn OTabBar( QWidget *parent = 0, const char *name = 0 )
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  *
  * Constructs a new OTabBar control with parent and name.
  */
  // FIXME Allow WFlags? -zecke
     OTabBar( QWidget * = 0, const char * = 0 );
 
 protected:
 /**
- * @fn paintLabel( QPainter* p, const QRect& br, QTab* t, bool has_focus )
+ * @fn paintLabel( QPainter* p, const QRect& br , QTab* t, bool  has_focus)const
  * @brief Internal function to draw a tab's label.
  *
  * @param p Pointer to QPainter used for drawing.
  * @param br QRect providing region to draw label in.
  * @param t Tab to draw label for.
  * @param has_focus Boolean value not used, retained for compatibility reasons.
  */
     void paintLabel( QPainter *, const QRect &, QTab *, bool ) const;
 };
 
 #endif
diff --git a/libopie/otabinfo.h b/libopie/otabinfo.h
index 6589638..eebaf8e 100644
--- a/libopie/otabinfo.h
+++ b/libopie/otabinfo.h
@@ -1,132 +1,132 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Dan Williams <williamsdr@acm.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 OTABINFO_H
 #define OTABINFO_H
 
 #include <qlist.h>
 #include <qstring.h>
 
 class QWidget;
 
 /**
  * @class OTabInfo
  * @brief The OTabInfo class is used internally by OTabWidget to keep track
  *        of widgets added to the control.
  *
  * OTabInfo provides the following information about a widget added to an
  * OTabWidget control:
  *
  *  ID - integer tab bar ID
  *  Control - QWidget pointer to child widget
  *  Label - QString text label for OTabWidget selection control
  *  Icon - QString name of icon file
  */
 class OTabInfo
 {
 public:
 /**
  * @fn OTabInfo()
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  * @param s Style of widget selection control.
  * @param p Position of the widget selection control.
  */
     OTabInfo() : i( -1 ), c( 0 ), p( 0 ), l( QString::null ) {}
 
 /**
  * @fn OTabInfo( int id, QWidget *control, const QString &icon, const QString &label )
  * @brief Object constructor.
  *
  * @param id TabBar identifier for widget.
  * @param control QWidget pointer to widget.
  * @param icon QString name of icon file.
  * @param label QString text label for OTabWidget selection control.
  */
     OTabInfo( int id, QWidget *control, const QString &icon, const QString &label )
         : i( id ), c( control ), p( icon ), l( label ) {}
 
 /**
- * @fn id()
+ * @fn id()const
  * @brief Returns TabBar ID.
  */
     int            id()      const { return i; }
 
 /**
- * @fn label()
+ * @fn label()const
  * @brief Returns text label for widget.
  */
     const QString &label()   const { return l; }
 
 /**
  * @fn setLabel( const QString &label )
  * @brief Set label for tab.
  *
  * @param label QString text label for OTabWidget selection control.
  */
     void setLabel( const QString &label ) { l = label; }
 
 /**
- * @fn control()
+ * @fn control()const
  * @brief Returns pointer to widget.
  */
     QWidget       *control() const { return c; }
 
 /**
- * @fn icon()
+ * @fn icon()const
  * @brief Returns name of icon file.
  */
     const QString &icon()    const { return p; }
 
 /**
  * @fn setIcon( const QString &icon )
  * @brief Set icon for tab.
  *
  * @param icon QString name of icon file.
  */
     void setIcon( const QString &icon ) { p = icon; }
 
 private:
     int      i;
     QWidget *c;
     QString  p;
     QString  l;
 };
 
 /**
  * @class OTabInfoList
  * @brief A list of OTabInfo objects used by OTabWidget.
  */
 typedef QList<OTabInfo> OTabInfoList;
 
 #endif
diff --git a/libopie/otabwidget.h b/libopie/otabwidget.h
index bcd9a85..a67fe06 100644
--- a/libopie/otabwidget.h
+++ b/libopie/otabwidget.h
@@ -1,276 +1,276 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Dan Williams <williamsdr@acm.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 OTABWIDGET_H
 #define OTABWIDGET_H
 
 #include "otabinfo.h"
 
 #include <qwidget.h>
 #include <qlist.h>
 
 class OTabBar;
 class QComboBox;
 class QPixmap;
 class QTabBar;
 class QWidgetStack;
 
 /**
  * @class OTabWidget
  * @brief The OTabWidget class provides a stack of widgets.
  *
  * OTabWidget is a derivation of TrollTech's QTabWidget which provides
  * a stack of widgets.  Widgets can be selected using either a tab bar or
  * drop down list box.
  *
  * The normal way to use OTabWidget is to do the following in the
  * constructor:
  * - Create a OTabWidget.
  * - Create a QWidget for each of the pages in the control, insert
  *   children into it, set up geometry management for it, and use addTab()
  *   to add the widget.
  */
 class OTabWidget : public QWidget
 {
     Q_OBJECT
 public:
 
 /**
  * @enum TabStyle
  * @brief Defines how the widget selection control is displayed.
  *
  * Valid values:
  * - Global: use globally selected options (qpe.conf - TabStyle & TabPosition)
  * - TextTab: Tabbed widget selection with text labels
  * - IconTab: Tabbed widget selection with icon labels, text label for active widget
  *            (similar to Opie launcher)
  * - TextList: Drop down list widget selection with text labels
  * - IconList: Drop down list widget selection with icon & text labels
  */
     enum TabStyle { Global, TextTab, IconTab, TextList, IconList };
 
 /**
  * @enum TabPosition
  * @brief Defines where the widget selection control is drawn.
  *
  * Valid values:
  * - Top: Widget selection control is drawn above widgets
  * - Bottom: Widget selection control is drawn below widgets
  */
     enum TabPosition { Top, Bottom };
 
 /**
  * @fn OTabWidget( QWidget *parent = 0, const char *name = 0, TabStyle s = Global, TabPosition p = Top )
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  * @param s Style of widget selection control.
  * @param p Position of the widget selection control.
  *
  * Constructs a new OTabWidget control with parent and name.  The style and position parameters
  * determine how the widget selection control will be displayed.
  */
  // FIXME WFlags? -zecke
     OTabWidget( QWidget * = 0, const char * = 0, TabStyle = Global, TabPosition = Top );
 
 /**
  * @fn ~OTabWidget()
  * @brief Object destructor.
  */
     ~OTabWidget();
 
 /**
  * @fn addTab( QWidget *child, const QString &icon, const QString &label )
  * @brief Add new widget to control.
  *
  * @param child Widget control.
  * @param icon Path to icon.
  * @param label Text label.
  */
     void addTab( QWidget *, const QString &, const QString & );
 
 /**
  * @fn removePage( QWidget *widget )
  * @brief Remove widget from control.  Does not delete widget.
  *
  * @param widget Widget control to be removed.
  */
     void removePage( QWidget * );
 
 /**
- * @fn changeTab( QWidget *widget, const QIconSet &icon, const QString &label )
+ * @fn changeTab( QWidget *widget, const QString &icon, const QString &label )
  * @brief Change text and/or icon for existing tab
  *
  * @param child Widget control.
  * @param icon Path to icon.
  * @param label Text label.
  */
     void changeTab( QWidget *, const QString &, const QString & );
 
 /**
- * @fn tabStyle()
+ * @fn tabStyle()const
  * @brief Returns current widget selection control style.
  */
     TabStyle tabStyle() const;
 
 /**
  * @fn setTabStyle( TabStyle s )
  * @brief Set the current widget selection control style.
  *
  * @param s New style to be used.
  */
     void setTabStyle( TabStyle );
 
 /**
- * @fn tabPosition()
+ * @fn tabPosition()const
  * @brief Returns current widget selection control position.
  */
     TabPosition tabPosition() const;
 
 /**
  * @fn setTabPosition( TabPosition p )
  * @brief Set the current widget selection control position.
  *
  * @param p New position of widget selection control.
  */
     void setTabPosition( TabPosition );
 
 /**
  * @fn setCurrentTab( QWidget *childwidget )
  * @brief Selects and brings to top the desired widget by using widget pointer.
  *
  * @param childwidget Widget to select.
  */
     void setCurrentTab( QWidget * );
 
 /**
  * @fn setCurrentTab( const QString &tabname )
  * @brief Selects and brings to top the desired widget, by using label.
  *
  * @param tabname Text label for widget to select.
  */
     void setCurrentTab( const QString & );
 
 /**
  * @fn setCurrentTab( int )
  * @brief Selects and brings to top the desired widget, by using id.
  *
  * @param tab id for widget to select.
  */
     void setCurrentTab(int);
 
 /**
- * @fn sizeHint()
+ * @fn sizeHint()const
  * @brief Reimplemented for internal purposes.
  */
     QSize sizeHint() const;
 
 /**
  * @fn currentTab( )
  * @brief returns current tab id.
  */
     int currentTab();
 
 
 protected:
 
 /**
  * @fn resizeEvent( QResizeEvent * )
  * @brief Reimplemented for internal purposes.
  */
     void resizeEvent( QResizeEvent * );
 
 private:
     OTabInfoList  tabs;
     OTabInfo     *currTab;
 
     TabStyle    tabBarStyle;
     TabPosition tabBarPosition;
 
     QWidgetStack *tabBarStack;
     OTabBar      *tabBar;
     QComboBox    *tabList;
 
     QWidgetStack *widgetStack;
 
 /**
  * @fn loadSmooth( const QString &name )
  * @brief Loads icon for widget.
  *
  * @param name Name of icon image file.
  */
     QPixmap loadSmooth( const QString & );
 
 /**
  * @fn selectTab( OTabInfo *tab )
  * @brief Internal function to select desired widget.
  *
  * @param tab Pointer to data for widget.
  */
     void    selectTab( OTabInfo * );
 
 /**
  * @fn setUpLayout()
  * @brief Internal function to adjust layout.
  */
     void    setUpLayout();
 
-    
+
 signals:
 /**
  * @fn currentChanegd( QWidget *widget )
  * @brief This signal is emitted whenever the widget has changed.
  *
  * @param widget Pointer to new current widget.
  */
     void currentChanged( QWidget * );
 
 private slots:
 
 /**
  * @fn slotTabBarSelected( int id )
  * @brief Slot which is called when a tab is selected.
  *
  * @param id ID of widget selected.
  */
     void slotTabBarSelected( int );
 
 /**
  * @fn slotTabListSelected( int index )
  * @brief Slot which is called when a drop down selection is made.
  *
  * @param id Index of widget selected.
  */
     void slotTabListSelected( int );
 };
 
 #endif
diff --git a/libopie/oticker.h b/libopie/oticker.h
index 30b7517..c848654 100644
--- a/libopie/oticker.h
+++ b/libopie/oticker.h
@@ -1,146 +1,147 @@
 /*
                             This file is part of the Opie Project
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           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 OTICKER_H
 #define OTICKER_H
 
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qdrawutil.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qslider.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qcolor.h>
 
 /**
  * @class OTicker
  * @brief The OTicker class provides a QLabel widget that scroll its contents
  *
  */
 class OTicker : public QLabel {
     Q_OBJECT
 
 public:
 
 /*!
  * @fn OTicker( QWidget* parent = 0 )
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
 
  * Constructs a new OTicker control with parent
  */
     OTicker( QWidget* parent=0 );
 /*!
  * @fn ~OTicker()
  * @brief Object destructor.
  */
     ~OTicker();
 /*!
- * @fn setText()
+ * @fn setText(const QString& )
  * @brief sets text to be displayed
  * @param text QString text to be displayed.
  *
  */
     void setText( const QString& text ) ;
 /*!
  * @fn setBackgroundColor(QColor color)
  * @brief sets color of the ticker's background
  * @param color QColor color to be set.
  *
  */
+    //FIXME const QColor& please -zecke
     void setBackgroundColor(QColor color);
 /*!
  * @fn setForegroundColor(QColor color)
  * @brief sets color of text
  * @param color QColor color of text
  *
  */
     void setForegroundColor(QColor color);
 /*!
  * @fn setFrame(int style)
  * @brief sets frame style
  * @param style int Frame style to be see. See Qt::WidgetFlags.
  *
  */
     void setFrame(int style);
 /*!
  * @fn setUpdateTime(int timeout)
  * @brief sets time of update
  * @param timeout int time in milliseconds between updates.
  *
  */
     void setUpdateTime(int timeout);
 /*!
  * @fn setScrollLength(int length)
  * @brief sets amount of scrolling default is 1
  * @param length int scroll length.
  *
  */
     void setScrollLength(int length);
 signals:
 /*!
  * @fn mousePressed()
  * @brief signal mouse press event
  *
  */
     void mousePressed();
 protected:
 /*!
  * @fn timerEvent( QTimerEvent * e)
  * @brief timer timeout event
  * @param e QEvent see QEvent.
  *
  */
     void timerEvent( QTimerEvent * e);
 /*!
  * @fn drawContents( QPainter *p )
  * @brief draws widget contents
  * @param p QPainter. see QPainter
  *
  */
     void drawContents( QPainter *p );
 /*!
  * @fn mouseReleaseEvent( QMouseEvent *e)
  * @brief mouse release event
  * @param e QMouseEvent. see QMouseEvent.
  *
  */
     void mouseReleaseEvent( QMouseEvent *e);
 private:
     QColor backgroundcolor, foregroundcolor;
     QString scrollText;
     QPixmap scrollTextPixmap;
     int pos, updateTimerTime, scrollLength;
 };
 
 #endif
diff --git a/libopie/otimepicker.h b/libopie/otimepicker.h
index 495c806..d501a95 100644
--- a/libopie/otimepicker.h
+++ b/libopie/otimepicker.h
@@ -1,81 +1,81 @@
 #ifndef OTIMEPICKER_H
 #define OTIMEPICKER_H
 
 #include <qwidget.h>
 #include <qvaluelist.h>
 #include <qdatetime.h>
 #include <qdialog.h>
 
 #include <opie/oclickablelabel.h>
 #include "otimepickerbase.h"
 
 /**
  * A class to pick time. It uses clickable labels
  * internally to allow a quick selection of a time.
  * A time can be selected by two clicks of a user
  *
  * @short A widget to quickly pick a QTime
  * @version 1.0
  * @see QWidget
  * @see QTime
  * @author Hakan Ardo, Stefan Eilers
  */
 class OTimePicker: public QWidget {
   Q_OBJECT
 
  public:
     OTimePicker(QWidget* parent = 0, const char* name = 0,
                WFlags fl = 0);
- 
-         public slots:      
+
+ public slots:
     void setHour(int h);
     void setMinute(int m);
     void setTime( const QTime& );
     void setTime( int h,  int m );
-    
+
  public:
     QTime time()const;
 
  private:
     QValueList<OClickableLabel *> hourLst;
     QValueList<OClickableLabel *> minuteLst;
     QTime tm;
     struct Private;
     Private *d;
 
  private slots:
     void slotHour(bool b);
     void slotMinute(bool b);
 
  signals:
     /**
      * gets emitted when the time got changed by the user
      */
     void timeChanged(const QTime &);
 };
 
 /**
  *
- * @short
+ * @short A small dialog to pick a time
  * @version 1.0
  * @author Stefan Eilers
  */
 
 class OTimePickerDialog: public OTimePickerDialogBase {
   Q_OBJECT
 
  public:
         OTimePickerDialog ( QWidget* parent = 0, const char* name = NULL, WFlags fl = 0 );
         ~OTimePickerDialog() { };
 
         QTime time()const;
 
  public slots:
         void setTime( const QTime& time );
         void setHour( const QString& hour );
         void setMinute( const QString& minute );
 
  private:
         QTime m_time;
 };
 #endif
diff --git a/libopie/todayconfigwidget.h b/libopie/todayconfigwidget.h
index 6b49efc..f3501a1 100644
--- a/libopie/todayconfigwidget.h
+++ b/libopie/todayconfigwidget.h
@@ -1,39 +1,39 @@
 
 #ifndef CONFIG_WIDGET_H
 #define CONFIG_WIDGET_H
 
 
 /**
  * A base class for all Today Config Widgets.
  * This will let a Today plugin to add the possibility of configuration.
  * Plugins need to inherit from this class and need to implement
  * the pure virtual method to control configuration.
  * The Plugin should read its configuration during creation of the Widget
  *
  *
  * @author Maximilian Reiß
  * @short base class of all today config widgets
  */
 class TodayConfigWidget : public QWidget {
 
 
 public:
 
     /**
      * This will construct the widget. The widget gets deleted once the parent
      * gets deleted as in any Qt application
      *
      * @param parent The parent of the widget
-     * @paran name The name of the object
+     * @param name The name of the object
      */
     TodayConfigWidget( QWidget *parent,  const char *name ) : QWidget( parent,  name ) {} ;
     virtual ~TodayConfigWidget() {};
 
     /**
      * Plugins need to reimplement this in the config widget
      * Used when the config dialog is closed to write config stuff
      */
     virtual void  writeConfig() = 0;
 };
 
 #endif
diff --git a/libopie/todayplugininterface.h b/libopie/todayplugininterface.h
index 29a12bc..532f492 100644
--- a/libopie/todayplugininterface.h
+++ b/libopie/todayplugininterface.h
@@ -1,106 +1,109 @@
 
 #ifndef TODAY_PLUGIN_INTERFACE
 #define TODAY_PLUGIN_INTERFACE
 
 #include <qpe/qcom.h>
 #include "todayconfigwidget.h"
 
 class QString;
 class QWidget;
 
 #ifndef IID_TodayPluginInterface
 #define IID_TodayPluginInterface QUuid( 0x70481804, 0x2b50, 0x4fba, 0x80, 0xbb, 0x0b, 0xf8, 0xdc, 0x72, 0x04, 0x14)
 #endif
 
 /**
  *
  * A TodayPluginObject is the base for all Today Plugins.
  * A plugin author needs to inherit this class and implement
  * the pure virtual methods
  *
  * @short base class for today plugins
  * @author Maximilian Reiss
  *
  */
 class TodayPluginObject {
 
 public:
 
     virtual ~TodayPluginObject() {};
 
     /**
      * The name if the plugin
      * @return The plugin should return its name here
      */
     virtual QString pluginName() const = 0;
 
     /**
      * Version numbering
      * @return The plugin should return the version number
      */
     virtual double versionNumber() const = 0;
 
 
     /**
      * @return the pixmap name widget?! -- FIXME
      */
     virtual  QString pixmapNameWidget() const = 0;
 
     /**
      * widget for the today view
      * It _needs_ a parent here.
      * Plugin authors need to take parent as parent!
      */
     virtual QWidget* widget( QWidget *parent ) = 0;
 
     /**
      * Pixmap used in the config widget
      */
     virtual QString pixmapNameConfig() const = 0;
 
     /**
      * Config plugin widget - optional
      * If the plugin has a config widget, it  _needs_  a parent here.
      * may return 0 if no config widget is needed
      */
     virtual TodayConfigWidget* configWidget( QWidget * ) = 0;
 
     /**
      * The application that should be assigned to the button (pixmap)
      * Today will show the plugin icon. On click it tries to execute the
      * plugin related application.
      */
     virtual QString appName() const = 0;
 
 
     /**
      * If the plugin should take part in the periodic refresh
      */
     virtual bool excludeFromRefresh() const = 0;
 
     /**
      * Refresh that plugins view. For updating the plugins
      *
      */
     virtual void refresh() {};
 
     /**
      * minimum height the plugin at least should have
      */
     // virtual int minHeight()  const = 0;
 
     /**
      *  maximum height that should be used before starting scrolling
      */
     // virtual int maxHeight() const = 0;
 
 };
 
 /**
  * This is part of the QCOM works. See example plugins how to do it right
  */
 struct TodayPluginInterface : public QUnknownInterface {
+    /**
+     * return the TodayPluginObject implementation
+     */
     virtual TodayPluginObject *guiPart() = 0;
 };
 
 #endif