run the optimize_connect script

the whole cvs is tagged with "before_optimize_connect" if there are problems you
can check the diff (but it had compiled and run here)

6 files changed, 41 insertions, 41 deletions

diff --git a/libopie2/opieui/fileselector/ofiledialog.cpp b/libopie2/opieui/fileselector/ofiledialog.cpp
index 2a89c5d..e7daead 100644
--- a/libopie2/opieui/fileselector/ofiledialog.cpp
+++ b/libopie2/opieui/fileselector/ofiledialog.cpp
@@ -1,222 +1,222 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (C) 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.
  
 */
 
 
 /* OPIE */
 #include <opie2/ofiledialog.h>
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qfileinfo.h>
 #include <qstring.h>
 #include <qapplication.h>
 #include <qlayout.h>
 
 using namespace Opie;
 
 namespace
 {
 /*
  * helper functions to load the start dir
  * and to save it
  * helper to extract the dir out of a file name
  */
 /**
  * This method will use Config( argv[0] );
  * @param key The group key used
  */
 QString lastUsedDir( const QString& key )
 {
     if ( qApp->argc() < 1 )
         return QString::null;
 
     Config cfg( QFileInfo(qApp->argv()[0]).fileName() ); // appname
     cfg.setGroup( key );
     return cfg.readEntry("LastDir", QPEApplication::documentDir() );
 }
 
 void saveLastDir( const QString& key, const QString& file )
 {
     if ( qApp->argc() < 1 )
         return;
 
     Config cfg(  QFileInfo(qApp->argv()[0]).fileName() );
     cfg.setGroup( key );
     QFileInfo inf( file );
     cfg.writeEntry("LastDir", inf.dirPath( true ) );
 }
 };
 
 /**
  * This constructs a modal dialog
  *
  * @param caption The caption of the dialog
  * @param wid The parent widget
  * @param mode The mode of the OFileSelector @see OFileSelector
  * @param selector The selector of the OFileSelector
  * @param dirName the dir or resource to start from
  * @param fileName  a proposed or existing filename
  * @param mimetypes The mimeTypes
  */
 OFileDialog::OFileDialog(const QString &caption,
                          QWidget *wid, int mode, int selector,
                          const QString &dirName,
                          const QString &fileName,
                          const QMap<QString,QStringList>& mimetypes )
         : QDialog( wid, "OFileDialog", true )
 {
     //  QVBoxLayout *lay = new QVBoxLayout(this);
     //showMaximized();
     QVBoxLayout *lay = new QVBoxLayout(this );
     file = new OFileSelector(this , mode, selector,
                              dirName, fileName,
                              mimetypes );
     lay->addWidget( file );
 
     //lay->addWidget( file );
     //showFullScreen();
     setCaption( caption.isEmpty() ? tr("FileDialog") : caption );
     connect(file, SIGNAL(fileSelected(const QString&) ),
             this, SLOT(slotFileSelected(const QString&) ) );
     connect(file, SIGNAL(ok() ),
             this, SLOT(slotSelectorOk()) ) ;
 
     connect(file, SIGNAL(dirSelected(const QString&) ), this, SLOT(slotDirSelected(const QString&) ) );
 
 #if 0
-    connect(file, SIGNAL(dirSelected(const QString &) ),
-            this, SLOT(slotDirSelected(const QString &) ) );
+    connect(file, SIGNAL(dirSelected(const QString&) ),
+            this, SLOT(slotDirSelected(const QString&) ) );
 #endif
 }
 /**
  * @returns the mimetype of the selected
  * currently it return QString::null
  */
 QString OFileDialog::mimetype()const
 {
     return QString::null;
 }
 
 /**
  * @return the fileName
  */
 QString OFileDialog::fileName()const
 {
     return file->selectedName();
 }
 
 /**
  * return a DocLnk to the current file
  */
 DocLnk OFileDialog::selectedDocument()const
 {
     return file->selectedDocument();
 }
 
 /**
  * This opens up a filedialog in Open mode
  *
  * @param selector the Selector Mode
  * @param startDir Where to start from
  * @param file A proposed filename
  * @param mimes A list of MimeTypes
  * @param wid the parent
  * @param caption of the dialog if QString::null tr("Open") will be used
  * @return the fileName or QString::null
  */
 QString OFileDialog::getOpenFileName(int selector,
                                      const QString &_startDir,
                                      const QString &file,
                                      const MimeTypes &mimes,
                                      QWidget *wid,
                                      const QString &caption )
 {
     QString ret;
     QString startDir = _startDir;
     if (startDir.isEmpty() )
         startDir = lastUsedDir( "FileDialog-OPEN" );
 
 
     OFileDialog dlg( caption.isEmpty() ? tr("Open") : caption,
                      wid, OFileSelector::Open, selector, startDir, file, mimes);
     dlg.showMaximized();
     if( dlg.exec() )
     {
         ret = dlg.fileName();
         saveLastDir( "FileDialog-OPEN", ret );
     }
 
     return ret;
 }
 
 /**
  * This opens up a file dialog in save mode
  * @see getOpenFileName
  */
 QString OFileDialog::getSaveFileName(int selector,
                                      const QString &_startDir,
                                      const QString &file,
                                      const MimeTypes &mimes,
                                      QWidget *wid,
                                      const QString &caption )
 {
     QString ret;
     QString startDir = _startDir;
     if (startDir.isEmpty() )
         startDir = lastUsedDir( "FileDialog-SAVE" );
 
     OFileDialog dlg( caption.isEmpty() ? tr("Save") : caption,
                      wid, OFileSelector::Save, selector, startDir, file, mimes);
     dlg.showMaximized();
     if( dlg.exec() )
     {
         ret = dlg.fileName();
         saveLastDir( "FileDialog-SAVE", ret );
     }
 
     return ret;
 }
 
 void OFileDialog::slotFileSelected(const QString & )
 {
     accept();
 }
 
 void OFileDialog::slotSelectorOk( )
 {
     accept();
 }
 
 void OFileDialog::slotDirSelected(const QString &dir )
 {
     setCaption( dir );
     // if mode
     //accept();
 }
diff --git a/libopie2/opieui/fileselector/ofileselector.cpp b/libopie2/opieui/fileselector/ofileselector.cpp
index 600daff..15cadd4 100644
--- a/libopie2/opieui/fileselector/ofileselector.cpp
+++ b/libopie2/opieui/fileselector/ofileselector.cpp
@@ -1,1166 +1,1166 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (C) 2002,2003 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.
 
 */
 
 /* hacky but we need to get FileSelector::filter */
 #define private public
 #include <qpe/fileselector.h>
 #undef private
 
 #include "ofileselector_p.h"
 
 /* OPIE */
 #include <opie2/ofileselector.h>
 
 #include <qpe/qpeapplication.h>
 #include <qpe/mimetype.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 
 /* QT */
 #include <qcombobox.h>
 #include <qdir.h>
 #include <qhbox.h>
 #include <qheader.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qlistview.h>
 #include <qpopupmenu.h>
 #include <qwidgetstack.h>
 #include <qregexp.h>
 #include <qobjectlist.h>
 
 using namespace Opie;
 
 OFileViewInterface::OFileViewInterface( OFileSelector* selector )
         : m_selector( selector )
 {}
 
 OFileViewInterface::~OFileViewInterface()
 {}
 
 QString OFileViewInterface::name()const
 {
     return m_name;
 }
 
 void OFileViewInterface::setName( const QString& name )
 {
     m_name = name;
 }
 
 OFileSelector* OFileViewInterface::selector()const
 {
     return m_selector;
 }
 
 DocLnk OFileViewInterface::selectedDocument()const
 {
     return DocLnk( selectedName() );
 }
 
 bool OFileViewInterface::showNew()const
 {
     return selector()->showNew();
 }
 
 bool OFileViewInterface::showClose()const
 {
     return selector()->showClose();
 }
 
 MimeTypes OFileViewInterface::mimeTypes()const
 {
     return selector()->mimeTypes();
 }
 
 QStringList OFileViewInterface::currentMimeType()const
 {
     return selector()->currentMimeType();
 }
 
 void OFileViewInterface::activate( const QString& )
 {
     // not implemented here
 }
 
 void OFileViewInterface::ok()
 {
     emit selector()->ok();
 }
 
 void OFileViewInterface::cancel()
 {
     emit selector()->cancel();
 }
 
 void OFileViewInterface::closeMe()
 {
     emit selector()->closeMe();
 }
 
 void OFileViewInterface::fileSelected( const QString& str)
 {
     emit selector()->fileSelected( str);
 }
 
 void OFileViewInterface::fileSelected( const DocLnk& lnk)
 {
     emit selector()->fileSelected( lnk );
 }
 
 void OFileViewInterface::setCurrentFileName( const QString& str )
 {
     selector()->m_lneEdit->setText( str );
 }
 
 QString OFileViewInterface::currentFileName()const
 {
     return selector()->m_lneEdit->text();
 }
 
 QString OFileViewInterface::startDirectory()const
 {
     return selector()->m_startDir;
 }
 
 ODocumentFileView::ODocumentFileView( OFileSelector* selector )
                   :OFileViewInterface( selector )
 {
     m_selector = 0;
     setName( QObject::tr("Documents") );
 }
 
 ODocumentFileView::~ODocumentFileView()
 {
 }
 
 QString ODocumentFileView::selectedName()const
 {
     if (!m_selector)
         return QString::null;
 
     return m_selector->selectedDocument().file();
 }
 
 QString ODocumentFileView::selectedPath()const
 {
     return QPEApplication::documentDir();
 }
 
 QString ODocumentFileView::directory()const
 {
     return selectedPath();
 }
 
 void ODocumentFileView::reread()
 {
     if (!m_selector)
         return;
 
     m_selector->setNewVisible( showNew() );
     m_selector->setCloseVisible( showClose() );
     m_selector->filter = currentMimeType().join(";");
     m_selector->reread();
 }
 
 int ODocumentFileView::fileCount()const
 {
     if (!m_selector)
         return -1;
 
     return m_selector->fileCount();
 }
 
 DocLnk ODocumentFileView::selectedDocument()const
 {
     if (!m_selector)
         return DocLnk();
 
     return m_selector->selectedDocument();
 }
 
 QWidget* ODocumentFileView::widget( QWidget* parent )
 {
     if (!m_selector )
     {
         m_selector = new FileSelector(currentMimeType().join(";"), parent, "fileselector", showNew(), showClose() );
-        QObject::connect(m_selector, SIGNAL(fileSelected( const DocLnk& ) ),
+        QObject::connect(m_selector, SIGNAL(fileSelected(const DocLnk&) ),
                          selector(), SLOT(slotDocLnkBridge(const DocLnk&) ) );
         QObject::connect(m_selector, SIGNAL(closeMe() ),
                          selector(), SIGNAL(closeMe() ) );
-        QObject::connect(m_selector, SIGNAL(newSelected(const DocLnk& ) ),
-                         selector(), SIGNAL(newSelected(const DocLnk& ) ) );
+        QObject::connect(m_selector, SIGNAL(newSelected(const DocLnk&) ),
+                         selector(), SIGNAL(newSelected(const DocLnk&) ) );
     }
 
     return m_selector;
 }
 
 /*
  * This is the file system view used
  * we use a QListView + QListViewItems for it
  */
 
 OFileSelectorItem::OFileSelectorItem( QListView* view, const QPixmap& pixmap,
                                       const QString& path, const QString& date,
                                       const QString& size, const QString& dir,
                                       bool isLocked, bool isDir )
         : QListViewItem( view )
 {
     setPixmap(0, pixmap );
     setText(1, path );
     setText(2, size );
     setText(3, date );
     m_isDir = isDir;
     m_dir = dir;
     m_locked = isLocked;
 }
 
 OFileSelectorItem::~OFileSelectorItem()
 {
 }
 
 bool OFileSelectorItem::isLocked()const
 {
     return m_locked;
 }
 
 QString OFileSelectorItem::directory()const
 {
     return m_dir;
 }
 
 bool OFileSelectorItem::isDir()const
 {
     return m_isDir;
 }
 
 QString OFileSelectorItem::path()const
 {
     return text( 1 );
 }
 
 QString OFileSelectorItem::key( int id, bool )const
 {
     QString ke;
     if( id == 0 || id == 1 )
     { // name
         if( m_isDir )
         {
             ke.append("0" );
             ke.append( text(1) );
         }
         else
         {
             ke.append("1" );
             ke.append( text(1) );
         }
         return ke;
     }
     else
         return text( id );
 
 }
 
 OFileViewFileListView::OFileViewFileListView( QWidget* parent, const QString& startDir, OFileSelector* sel)
                       :QWidget( parent ), m_sel( sel )
 {
     m_all = false;
     QVBoxLayout* lay = new QVBoxLayout( this );
     m_currentDir = startDir;
 
     /*
      * now we add a special bar
      * One Button For Up
      * Home
      * Doc
      * And a dropdown menu with FileSystems
      * FUTURE: one to change dir with lineedit
      * Bookmarks
      * Create Dir
      */
     QHBox* box = new QHBox(this );
     box->setBackgroundMode( PaletteButton );
     box->setSpacing( 0 );
 
     QToolButton *btn = new QToolButton( box );
     btn->setIconSet( Resource::loadIconSet("up") );
     connect(btn, SIGNAL(clicked() ),
             this, SLOT( cdUP() ) );
 
     btn = new QToolButton( box );
     btn->setIconSet( Resource::loadIconSet("home") );
     connect(btn, SIGNAL(clicked() ),
             this, SLOT( cdHome() ) );
 
     btn = new QToolButton( box );
     btn->setIconSet( Resource::loadIconSet("DocsIcon") );
     connect(btn, SIGNAL(clicked() ),
             this, SLOT(cdDoc() ) );
 
     m_btnNew = new QToolButton( box );
     m_btnNew->setIconSet( Resource::loadIconSet("new") );
     connect(m_btnNew, SIGNAL(clicked() ),
             this, SLOT(slotNew() ) );
 
 
     m_btnClose = new QToolButton( box );
     m_btnClose->setIconSet( Resource::loadIconSet("close") );
     connect(m_btnClose, SIGNAL(clicked() ),
             selector(), SIGNAL(closeMe() ) );
 
     btn = new QToolButton( box );
     btn->setIconSet( Resource::loadIconSet("cardmon/pcmcia") );
 
     /* let's fill device parts */
     QPopupMenu* pop = new QPopupMenu(this);
     connect(pop, SIGNAL( activated(int) ),
             this, SLOT(slotFSActivated(int) ) );
 
     StorageInfo storage;
     const QList<FileSystem> &fs = storage.fileSystems();
     QListIterator<FileSystem> it(fs);
     for ( ; it.current(); ++it )
     {
         const QString disk = (*it)->name();
         const QString path = (*it)->path();
         m_dev.insert( disk, path );
         pop->insertItem( disk );
     }
     m_fsPop = pop;
 
 
     btn->setPopup( pop );
 
     lay->addWidget( box );
 
     m_view = new QListView( this );
 
     m_view->installEventFilter(this);
 
     QPEApplication::setStylusOperation( m_view->viewport(),
                                         QPEApplication::RightOnHold);
     m_view->addColumn(" " );
     m_view->addColumn(tr("Name"), 135 );
     m_view->addColumn(tr("Size"), -1 );
     m_view->addColumn(tr("Date"), 60 );
     m_view->addColumn(tr("Mime Type"), -1 );
 
 
     m_view->setSorting( 1 );
     m_view->setAllColumnsShowFocus( TRUE );
 
     lay->addWidget( m_view, 1000 );
     connectSlots();
 }
 
 OFileViewFileListView::~OFileViewFileListView()
 {
 }
 
 void OFileViewFileListView::slotNew()
 {
     DocLnk lnk;
     emit selector()->newSelected( lnk );
 }
 
 OFileSelectorItem* OFileViewFileListView::currentItem()const
 {
     QListViewItem* item = m_view->currentItem();
     if (!item )
         return 0l;
 
     return static_cast<OFileSelectorItem*>(item);
 }
 
 void OFileViewFileListView::reread( bool all )
 {
     m_view->clear();
 
     if (selector()->showClose() )
         m_btnClose->show();
     else
         m_btnClose->hide();
 
     if (selector()->showNew() )
         m_btnNew->show();
     else
         m_btnNew->hide();
 
     m_mimes = selector()->currentMimeType();
     m_all = all;
 
     QDir dir( m_currentDir );
     if (!dir.exists() )
         return;
 
     dir.setSorting( QDir::Name | QDir::DirsFirst | QDir::Reversed );
     int filter;
     if (m_all )
         filter = QDir::Files | QDir::Dirs | QDir::Hidden | QDir::All;
     else
         filter = QDir::Files | QDir::Dirs | QDir::All;
     dir.setFilter( filter );
 
     // now go through all files
     const QFileInfoList *list = dir.entryInfoList();
     if (!list)
     {
         cdUP();
         return;
     }
 
     QFileInfoListIterator it( *list );
     QFileInfo *fi;
     while( (fi=it.current() ) )
     {
         if( fi->fileName() == QString::fromLatin1("..") || fi->fileName() == QString::fromLatin1(".") )
         {
             ++it;
             continue;
         }
 
         /*
          * It is a symlink we try to resolve it now but don't let us attack by DOS
          *
          */
         if( fi->isSymLink() )
         {
             QString file = fi->dirPath( true ) + "/" + fi->readLink();
             for( int i = 0; i<=4; i++)
             { // 5 tries to prevent dos
                 QFileInfo info( file );
                 if( !info.exists() )
                 {
                     addSymlink( fi, TRUE );
                     break;
                 }
                 else if( info.isDir() )
                 {
                     addDir( fi, TRUE );
                     break;
                 }
                 else if( info.isFile() )
                 {
                     addFile( fi, TRUE );
                     break;
                 }
                 else if( info.isSymLink() )
                 {
                     file = info.dirPath(true ) + "/" + info.readLink() ;
                     break;
                 }
                 else if( i == 4)
                 { // couldn't resolve symlink add it as symlink
                     addSymlink( fi );
                 }
             } // off for loop for symlink resolving
         }
         else if( fi->isDir() )
             addDir(  fi );
         else if( fi->isFile() )
             addFile( fi );
 
         ++it;
     } // of while loop
     m_view->sort();
 
 }
 int OFileViewFileListView::fileCount()const
 {
     return m_view->childCount();
 }
 
 QString OFileViewFileListView::currentDir()const
 {
     return m_currentDir;
 }
 
 OFileSelector* OFileViewFileListView::selector()
 {
     return m_sel;
 }
 
 bool OFileViewFileListView::eventFilter (QObject *o, QEvent *e)
 {
     if ( e->type() == QEvent::KeyPress )
     {
         QKeyEvent *k = (QKeyEvent *)e;
         if ( (k->key()==Key_Enter) || (k->key()==Key_Return))
         {
             slotClicked( Qt::LeftButton,m_view->currentItem(),QPoint(0,0),0);
             return true;
         }
     }
     return false;
 }
 
 void OFileViewFileListView::connectSlots()
 {
     connect(m_view, SIGNAL(clicked(QListViewItem*) ),
             this, SLOT(slotCurrentChanged(QListViewItem*) ) );
-    connect(m_view, SIGNAL(mouseButtonClicked(int, QListViewItem*, const QPoint&, int ) ),
-            this, SLOT(slotClicked(int, QListViewItem*, const QPoint&, int ) ) );
+    connect(m_view, SIGNAL(mouseButtonClicked(int,QListViewItem*,const QPoint&,int) ),
+            this, SLOT(slotClicked(int,QListViewItem*,const QPoint&,int) ) );
 }
 
 void OFileViewFileListView::slotCurrentChanged( QListViewItem* item)
 {
     if (!item)
         return;
 #if 0
 
     OFileSelectorItem *sel = static_cast<OFileSelectorItem*>(item);
 
     if (!sel->isDir() )
     {
         selector()->m_lneEdit->setText( sel->text(1) );
         // if in fileselector mode we will emit selected
         if ( selector()->mode() == OFileSelector::FileSelector )
         {
             qWarning("slot Current Changed");
             QStringList str = QStringList::split("->", sel->text(1) );
             QString path = sel->directory() + "/" + str[0].stripWhiteSpace();
             emit selector()->fileSelected( path );
             DocLnk lnk( path );
             emit selector()->fileSelected( lnk );
         }
     }
 #endif
 }
 
 void OFileViewFileListView::slotClicked(int button , QListViewItem* item, const QPoint&, int )
 {
     if (!item || ( button != Qt::LeftButton) )
         return;
 
     OFileSelectorItem *sel = static_cast<OFileSelectorItem*>(item);
     if (!sel->isLocked() )
     {
         QStringList str = QStringList::split("->", sel->text(1) );
         if (sel->isDir() )
         {
             m_currentDir = sel->directory() + "/" + str[0].stripWhiteSpace();
             emit selector()->dirSelected( m_currentDir );
             reread( m_all );
         }
         else
         { // file
             qWarning("slot Clicked");
             selector()->m_lneEdit->setText( str[0].stripWhiteSpace() );
             QString path = sel->directory() + "/" + str[0].stripWhiteSpace();
             emit selector()->fileSelected( path );
             DocLnk lnk( path );
             emit selector()->fileSelected( lnk );
         }
     } // not locked
 }
 
 void OFileViewFileListView::addFile( QFileInfo* info, bool symlink )
 {
     MimeType type( info->absFilePath() );
     if (!compliesMime( type.id() ) )
         return;
 
     QPixmap pix = type.pixmap();
     QString dir, name; bool locked;
     if ( pix.isNull() )
     {
         QWMatrix matrix;
         QPixmap pixer(Resource::loadPixmap("UnknownDocument") );
         matrix.scale( .4, .4 );
         pix = pixer.xForm( matrix );
     }
     dir = info->dirPath( true );
     locked = false;
     if ( symlink )
         name = info->fileName() + " -> " + info->dirPath() + "/" + info->readLink();
     else
     {
         name = info->fileName();
         if ( ( (selector()->mode() == OFileSelector::Open)&& !info->isReadable() ) ||
                 ( (selector()->mode() == OFileSelector::Save)&& !info->isWritable() ) )
         {
             locked = true; pix = Resource::loadPixmap("locked");
         }
     }
     (void)new OFileSelectorItem( m_view, pix, name,
                                  info->lastModified().toString(), QString::number( info->size() ),
                                  dir, locked );
 }
 
 void OFileViewFileListView::addDir( QFileInfo* info, bool symlink )
 {
     bool locked = false; QString name; QPixmap pix;
 
     if ( ( ( selector()->mode() == OFileSelector::Open )  && !info->isReadable() ) ||
             ( ( selector()->mode() == OFileSelector::Save )  && !info->isWritable() ) )
     {
         locked = true;
         if ( symlink )
             pix = Resource::loadPixmap( "opie/symlink" );
         else
             pix = Resource::loadPixmap( "lockedfolder" );
     }
     else
         pix = symlink ? Resource::loadPixmap( "opie/symlink") : Resource::loadPixmap("folder");
 
     name = symlink ? info->fileName() + " -> " + info->dirPath(true) + "/" + info->readLink() :
            info->fileName();
 
     (void)new OFileSelectorItem( m_view, pix, name,
                                  info->lastModified().toString(),
                                  QString::number( info->size() ),
                                  info->dirPath( true ), locked, true );
 
 
 }
 
 void OFileViewFileListView::addSymlink( QFileInfo* , bool )
 {
 }
 
 void OFileViewFileListView::cdUP()
 {
     QDir dir( m_currentDir );
     dir.cdUp();
 
     if (!dir.exists() )
         m_currentDir = "/";
     else
         m_currentDir = dir.absPath();
 
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 
 void OFileViewFileListView::cdHome()
 {
     m_currentDir = QDir::homeDirPath();
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 
 void OFileViewFileListView::cdDoc()
 {
     m_currentDir = QPEApplication::documentDir();
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 
 void OFileViewFileListView::changeDir( const QString& dir )
 {
     m_currentDir = dir;
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 
 void OFileViewFileListView::slotFSActivated( int id )
 {
     changeDir ( m_dev[m_fsPop->text(id)]  );
 }
 
 /*  check if the mimetype in mime
  *  complies with the  one which is current
  */
 /*
  * We've the mimetype of the file
  * We need to get the stringlist of the current mimetype
  *
  * mime = image@slashjpeg
  * QStringList = 'image@slash*'
  * or QStringList = image/jpeg;image/png;application/x-ogg
  * or QStringList = application/x-ogg;image@slash*;
  * with all these mime filters it should get acceptes
  * to do so we need to look if mime is contained inside
  * the stringlist
  * if it's contained return true
  * if not ( I'm no RegExp expert at all ) we'll look if a '@slash*'
  * is contained in the mimefilter and then we will
  * look if both are equal until the '/'
  */
 
 bool OFileViewFileListView::compliesMime( const QString& str)
 {
     if (str.isEmpty() || m_mimes.isEmpty() || str.stripWhiteSpace().isEmpty() )
         return true;
 
     for (QStringList::Iterator it = m_mimes.begin(); it != m_mimes.end(); ++it )
     {
         QRegExp reg( (*it) );
         reg.setWildcard( true );
         if ( str.find( reg ) != -1 )
             return true;
 
     }
     return false;
 }
 /*
  * The listView giving access to the file system!
  */
 
 class OFileViewFileSystem : public OFileViewInterface
 {
 public:
     OFileViewFileSystem( OFileSelector* );
     ~OFileViewFileSystem();
 
     QString selectedName() const;
     QString selectedPath() const;
 
     QString directory()const;
     void reread();
     int fileCount()const;
 
     QWidget* widget( QWidget* parent );
     void activate( const QString& );
 private:
     OFileViewFileListView* m_view;
     bool m_all : 1;
 };
 
 OFileViewFileSystem::OFileViewFileSystem( OFileSelector* sel)
         : OFileViewInterface( sel )
 {
     m_view = 0;
     m_all = false;
 }
 
 OFileViewFileSystem::~OFileViewFileSystem()
 {
 }
 
 QString OFileViewFileSystem::selectedName()const
 {
     if (!m_view )
         return QString::null;
 
     QString cFN=currentFileName();
     if (cFN.startsWith("/")) return cFN;
     return m_view->currentDir() + "/" + cFN;
 }
 
 QString OFileViewFileSystem::selectedPath()const
 {
     return QString::null;
 }
 
 QString OFileViewFileSystem::directory()const
 {
     if (!m_view)
         return QString::null;
 
     OFileSelectorItem* item = m_view->currentItem();
     if (!item )
         return QString::null;
 
     return QDir(item->directory() ).absPath();
 }
 
 void OFileViewFileSystem::reread()
 {
     if (!m_view)
         return;
 
     m_view->reread( m_all );
 }
 
 int OFileViewFileSystem::fileCount()const
 {
     if (!m_view )
         return -1;
     return m_view->fileCount();
 }
 
 QWidget* OFileViewFileSystem::widget( QWidget* parent )
 {
     if (!m_view )
     {
         m_view = new OFileViewFileListView( parent, startDirectory(), selector() );
     }
     return m_view;
 }
 
 void OFileViewFileSystem::activate( const QString& str)
 {
     m_all = (str != QObject::tr("Files") );
 }
 
 /* Selector */
 /**
  * @short new and complete c'tor
  *
  * Create a OFileSelector to let the user select a file. It can
  * either be used to open a file, select a save name in a dir or
  * as a dropin for the FileSelector.
  *
  * <pre>
  *  QMap<QString, QStringList> mimeTypes;
  *  QStringList types;
  *  types << "text@slash* ";
  *  types << "audio@slash*";
  *  mimeTypes.insert( tr("Audio and Text"), types );
  *  mimeTypes.insert( tr("All"), "*@slash*);
  *
  *  now you could create your fileselector
  * </pre>
  *
  *
  * @param parent the parent of this widget
  * @param mode The mode from the enum Mode (Open,Save,FILESELECTOR)
  * @param sel The  selector to be used
  * @param dirName The name of the dir to start int
  * @param fileName The fileName placed in the fileselector lineedit
  * @param mimetypes The MimeType map of used mimetypes
  * @param showNew Show a New Button. Most likely to be used in the FileSelector view.
  * @param showClose Show a Close Button. Most likely to be used in FileSelector view.
  *
  */
 OFileSelector::OFileSelector( QWidget* parent, int mode, int sel,
                               const QString& dirName, const QString& fileName,
                               const MimeTypes& mimetypes,
                               bool showNew,  bool showClose)
               :QWidget( parent, "OFileSelector" )
 {
     m_current = 0;
     m_shNew = showNew;
     m_shClose = showClose;
     m_mimeType = mimetypes;
     m_startDir = dirName;
 
     m_mode = mode;
     m_selector = sel;
 
     initUI();
     m_lneEdit->setText( fileName );
     initMime();
     initViews();
 
     QString str;
     switch ( m_selector )
     {
     default:
     case Normal:
         str = QObject::tr("Documents");
         m_cmbView->setCurrentItem( 0 );
         break;
     case Extended:
         str = QObject::tr("Files");
         m_cmbView->setCurrentItem( 1 );
         break;
     case ExtendedAll:
         str = QObject::tr("All Files");
         m_cmbView->setCurrentItem( 2 );
         break;
     }
     slotViewChange( str );
 
 }
 
 
 /**
  * This a convience c'tor to just substitute the use of FileSelector
  */
 OFileSelector::OFileSelector( const QString& mimeFilter, QWidget* parent, const char* name,
                               bool showNew, bool showClose )
         : QWidget( parent, name )
 {
     m_current = 0;
     m_shNew   = showNew;
     m_shClose = showClose;
     m_startDir = QPEApplication::documentDir();
 
     if (!mimeFilter.isEmpty() )
         m_mimeType.insert(mimeFilter, QStringList::split(";", mimeFilter ) );
 
     m_mode = OFileSelector::FileSelector;
     m_selector = OFileSelector::Normal;
 
     initUI();
     initMime();
     initViews();
     m_cmbView->setCurrentItem( 0 );
     slotViewChange( QObject::tr("Documents") );
 }
 
 /*
  * INIT UI will set up the basic GUI
  * Layout: Simple VBoxLayout
  * On top a WidgetStack containing the Views...
  *  - List View
  *  - Document View
  * Below we will have a Label + LineEdit
  * Below we will have two ComoBoxes one for choosing the view one for
  *       choosing the mimetype
  */
 void OFileSelector::initUI()
 {
     QVBoxLayout* lay = new QVBoxLayout( this );
 
     m_stack = new QWidgetStack( this );
     lay->addWidget( m_stack, 1000 );
 
     m_nameBox = new QHBox( this );
     (void)new QLabel( tr("Name:"), m_nameBox );
     m_lneEdit = new QLineEdit( m_nameBox );
     m_lneEdit ->installEventFilter(this);
     lay->addWidget( m_nameBox );
 
     m_cmbBox = new QHBox( this );
     m_cmbView = new QComboBox( m_cmbBox );
     m_cmbMime = new QComboBox( m_cmbBox );
     lay->addWidget( m_cmbBox );
 }
 
 /*
  * This will make sure that the return key in the name edit causes dialogs to close
  */
 
 bool OFileSelector::eventFilter (QObject *o, QEvent *e)
 {
     if ( e->type() == QEvent::KeyPress )
     {
         QKeyEvent *k = (QKeyEvent *)e;
         if ( (k->key()==Key_Enter) || (k->key()==Key_Return))
         {
             emit ok();
             return true;
         }
     }
     return false;
 }
 
 /*
  * This will insert the MimeTypes into the Combo Box
  * And also connect the changed signal
  *
  * AutoMimeTyping is disabled for now. It used to reparse a dir and then set available mimetypes
  */
 void OFileSelector::initMime()
 {
     MimeTypes::Iterator it;
     for ( it = m_mimeType.begin(); it != m_mimeType.end(); ++it )
     {
         m_cmbMime->insertItem( it.key() );
     }
     m_cmbMime->setCurrentItem( 0 );
 
     connect( m_cmbMime, SIGNAL(activated(int) ),
              this, SLOT(slotMimeTypeChanged() ) );
 
 }
 
 void OFileSelector::initViews()
 {
     m_cmbView->insertItem( QObject::tr("Documents") );
     m_cmbView->insertItem( QObject::tr("Files") );
     m_cmbView->insertItem( QObject::tr("All Files") );
-    connect(m_cmbView, SIGNAL(activated( const QString& ) ),
-            this, SLOT(slotViewChange( const QString& ) ) );
+    connect(m_cmbView, SIGNAL(activated(const QString&) ),
+            this, SLOT(slotViewChange(const QString&) ) );
 
 
     m_views.insert( QObject::tr("Documents"), new ODocumentFileView(this) );
 
     /* see above why add both */
     OFileViewInterface* in = new OFileViewFileSystem( this );
     m_views.insert( QObject::tr("Files"), in );
     m_views.insert( QObject::tr("All Files"), in );
 }
 
 /**
  * d'tor
  */
 OFileSelector::~OFileSelector()
 {
 }
 
 
 
 /**
  * Convience function for the fileselector
  * make sure to delete the DocLnk
  *
  * @see DocLnk
  * @todo remove in ODP
  */
 const DocLnk* OFileSelector::selected()
 {
     DocLnk* lnk = new DocLnk( currentView()->selectedDocument() );
     return lnk;
 }
 
 /**
  *
  * @return the name of the selected file
  */
 QString OFileSelector::selectedName()const
 {
     return currentView()->selectedName();
 }
 
 
 /**
  * @return the selected path
  */
 QString OFileSelector::selectedPath()const
 {
     return currentView()->selectedPath();
 }
 
 /**
  * @return the directory name
  */
 QString OFileSelector::directory()const
 {
     return currentView()->directory();
 }
 
 /**
  * @return a DocLnk for the selected document
  */
 DocLnk OFileSelector::selectedDocument()const
 {
     return currentView()->selectedDocument();
 }
 
 /**
  * @return the number of items for the current view
  */
 int OFileSelector::fileCount()const
 {
     return currentView()->fileCount();
 }
 
 /**
  * @return  reparse the file content
  */
 void OFileSelector::reread()
 {
     return currentView()->reread();
 }
 
 OFileViewInterface* OFileSelector::currentView()const
 {
     return m_current;
 }
 
 bool OFileSelector::showNew()const
 {
     return m_shNew;
 }
 
 bool OFileSelector::showClose()const
 {
     return m_shClose;
 }
 
 MimeTypes OFileSelector::mimeTypes()const
 {
     return m_mimeType;
 }
 
 /**
  * @return the Mode of the OFileSelector
  */
 int OFileSelector::mode()const
 {
     return m_mode;
 }
 
 
 /**
  * @return the Selector of the OFileSelector
  */
 int OFileSelector::selector()const
 {
     return m_selector;
 }
 
 QStringList OFileSelector::currentMimeType()const
 {
     return m_mimeType[m_cmbMime->currentText()];
 }
 
 void OFileSelector::slotMimeTypeChanged()
 {
     reread();
 }
 
 void OFileSelector::slotDocLnkBridge( const DocLnk& lnk)
 {
     m_lneEdit->setText( lnk.name() );
     emit fileSelected( lnk );
     emit fileSelected( lnk.name() );
 }
 
 void OFileSelector::slotFileBridge( const QString& str)
 {
     DocLnk lnk( str );
     emit fileSelected( lnk );
 }
 
 void OFileSelector::slotViewChange( const QString& view )
 {
     OFileViewInterface* interface = m_views[view];
     if (!interface)
         return;
 
     interface->activate( view );
     if (m_current)
         m_stack->removeWidget( m_current->widget( m_stack ) );
 
     static int id = 1;
 
     m_stack->addWidget( interface->widget(m_stack), id );
     m_stack->raiseWidget( id );
 
     interface->reread();
     m_current = interface;
 
     id++;
 }
 
 void OFileSelector::setNewVisible( bool b )
 {
     m_shNew = b;
     currentView()->reread();
 }
 
 void OFileSelector::setCloseVisible( bool b )
 {
     m_shClose = b;
     currentView()->reread();
 }
 
 void OFileSelector::setNameVisible( bool b )
 {
     if ( b )
         m_nameBox->show();
     else
         m_nameBox->hide();
 }
 
diff --git a/libopie2/opieui/ofontselector.cpp b/libopie2/opieui/ofontselector.cpp
index 49ddeb6..f93781f 100644
--- a/libopie2/opieui/ofontselector.cpp
+++ b/libopie2/opieui/ofontselector.cpp
@@ -1,428 +1,428 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) Robert Griebl <sandman@handhelds.org>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 /* OPIE */
 #include <opie2/ofontselector.h>
 #include <qpe/fontdatabase.h>
 
 /* QT */
 #include <qlayout.h>
 #include <qlistbox.h>
 #include <qcombobox.h>
 #include <qlabel.h>
 #include <qmultilineedit.h>
 
 using namespace Opie;
 
 namespace Opie
 {
 
 class OFontSelectorPrivate
 {
 public:
     QListBox *      m_font_family_list;
     QComboBox *     m_font_style_list;
     QComboBox *     m_font_size_list;
     QMultiLineEdit *m_preview;
 
     bool            m_pointbug : 1;
 
     FontDatabase    m_fdb;
 };
 
 };
 
 namespace
 {
 
 class FontListItem : public QListBoxText
 {
 public:
     FontListItem ( const QString &t, const QStringList &styles, const QValueList<int> &sizes ) : QListBoxText()
     {
         m_name = t;
         m_styles = styles;
         m_sizes = sizes;
 
         QString str = t;
         str [0] = str [0]. upper();
         setText ( str );
     }
 
     QString family() const
     {
         return m_name;
     }
 
     const QStringList &styles() const
     {
         return m_styles;
     }
 
     const QValueList<int> &sizes() const
     {
         return m_sizes;
     }
 
 private:
     QStringList m_styles;
     QValueList<int> m_sizes;
     QString m_name;
 };
 
 
 static int findItemCB( QComboBox *box, const QString &str )
 {
     for ( int i = 0; i < box->count(); i++ )
     {
         if ( box->text ( i ) == str )
             return i;
     }
     return -1;
 }
 
 }
 /* static same as anon. namespace */
 static int qt_version()
 {
     const char *qver = qVersion();
 
     return ( qver [0] - '0' ) * 100 + ( qver [2] - '0' ) * 10 + ( qver [4] - '0' );
 }
 
 /**
  * Constructs the Selector object
  * @param withpreview If a font preview should be given
  * @param parent The parent of the Font Selector
  * @param name The name of the object
  * @param fl WidgetFlags
  */
 OFontSelector::OFontSelector( bool withpreview, QWidget *parent, const char *name, WFlags fl ) : QWidget ( parent, name, fl )
 {
     d = new OFontSelectorPrivate();
 
     QGridLayout *gridLayout = new QGridLayout( this, 0, 0, 4, 4 );
     gridLayout->setRowStretch( 4, 10 );
 
     d->m_font_family_list = new QListBox( this, "FontListBox" );
     gridLayout->addMultiCellWidget( d->m_font_family_list, 0, 4, 0, 0 );
-    connect( d->m_font_family_list, SIGNAL( highlighted( int ) ), this, SLOT( fontFamilyClicked( int ) ) );
+    connect( d->m_font_family_list, SIGNAL( highlighted(int) ), this, SLOT( fontFamilyClicked(int) ) );
 
     QLabel *label = new QLabel( tr( "Style" ), this );
     gridLayout->addWidget( label, 0, 1 );
 
     d->m_font_style_list = new QComboBox( this, "StyleListBox" );
-    connect( d->m_font_style_list, SIGNAL(  activated( int ) ), this, SLOT( fontStyleClicked( int ) ) );
+    connect( d->m_font_style_list, SIGNAL(  activated(int) ), this, SLOT( fontStyleClicked(int) ) );
     gridLayout->addWidget( d->m_font_style_list, 1, 1 );
 
     label = new QLabel( tr( "Size" ), this );
     gridLayout->addWidget( label, 2, 1 );
 
     d->m_font_size_list = new QComboBox( this, "SizeListBox" );
-    connect( d->m_font_size_list, SIGNAL(  activated( int ) ),
-             this, SLOT( fontSizeClicked( int ) ) );
+    connect( d->m_font_size_list, SIGNAL(  activated(int) ),
+             this, SLOT( fontSizeClicked(int) ) );
     gridLayout->addWidget( d->m_font_size_list, 3, 1 );
 
     d->m_pointbug = ( qt_version() <= 233 );
 
     if ( withpreview )
     {
         d->m_preview = new QMultiLineEdit ( this, "Preview" );
         d->m_preview->setAlignment ( AlignCenter );
         d->m_preview->setWordWrap ( QMultiLineEdit::WidgetWidth );
         d->m_preview->setMargin ( 3 );
         d->m_preview->setText ( tr( "The Quick Brown Fox Jumps Over The Lazy Dog" ));
         gridLayout->addRowSpacing ( 5, 4 );
         gridLayout->addMultiCellWidget ( d->m_preview, 6, 6, 0, 1 );
         gridLayout->setRowStretch ( 6, 5 );
     }
     else
         d->m_preview = 0;
 
     loadFonts ( d->m_font_family_list );
 }
 
 OFontSelector::~OFontSelector()
 {
     delete d;
 }
 
 /**
  * This methods tries to set the font
  * @param f The wishes font
  * @return success or failure
  */
 bool OFontSelector::setSelectedFont ( const QFont &f )
 {
     return setSelectedFont ( f. family(), d->m_fdb. styleString ( f ), f. pointSize(), QFont::encodingName ( f. charSet()));
 }
 
 
 /**
  * This is an overloaded method @see setSelectedFont
  * @param familyStr The family of the font
  * @param styleStr The style of the font
  * @param sizeVal The size of font
  * @param charset The charset to be used. Will be deprecated by QT3
  */
 bool OFontSelector::setSelectedFont( const QString &familyStr, const QString &styleStr, int sizeVal, const QString & charset )
 {
     QString sizeStr = QString::number ( sizeVal );
 
     QListBoxItem *family = d->m_font_family_list->findItem ( familyStr );
     if ( !family )
         family = d->m_font_family_list->findItem ( "Helvetica" );
     if ( !family )
         family = d->m_font_family_list->firstItem();
     d->m_font_family_list->setCurrentItem ( family );
     fontFamilyClicked ( d->m_font_family_list->index ( family ));
 
     int style = findItemCB ( d->m_font_style_list, styleStr );
     if ( style < 0 )
         style = findItemCB ( d->m_font_style_list, "Regular" );
     if ( style < 0 && d->m_font_style_list->count() > 0 )
         style = 0;
     d->m_font_style_list->setCurrentItem ( style );
     fontStyleClicked ( style );
 
     int size = findItemCB ( d->m_font_size_list, sizeStr );
     if ( size < 0 )
         size = findItemCB ( d->m_font_size_list, "10" );
     if ( size < 0 && d->m_font_size_list->count() > 0 )
         size = 0;
     d->m_font_size_list->setCurrentItem ( size );
     fontSizeClicked ( size );
 
     return (( family ) && ( style >= 0 ) && ( size >= 0 ));
 }
 
 /**
  * This method returns the name, style and size of the currently selected
  * font or false if no font is selected
  * @param family The font family will be written there
  * @param style The style will be written there
  * @param size The size will be written there
  * @return success or failure
  */
 bool OFontSelector::selectedFont ( QString &family, QString &style, int &size )
 {
     QString dummy;
     return selectedFont ( family, style, size, dummy );
 }
 
 
 /**
  * This method does return the font family or QString::null if there is
  * no font item selected
  * @return the font family
  */
 QString OFontSelector::fontFamily() const
 {
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( d->m_font_family_list->currentItem());
 
     return fli ? fli->family() : QString::null;
 }
 
 /**
  * This method will return the style of the font or QString::null
  * @return the style of the font
  */
 QString OFontSelector::fontStyle() const
 {
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( d->m_font_family_list->currentItem());
     int fst = d->m_font_style_list->currentItem();
 
     return ( fli && fst >= 0 ) ? fli->styles() [fst] : QString::null;
 }
 
 /**
  * This method will return the font size or 10 if no font size is available
  */
 int OFontSelector::fontSize() const
 {
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( d->m_font_family_list->currentItem());
     int fsi = d->m_font_size_list->currentItem();
 
     return ( fli && fsi >= 0 ) ? fli->sizes() [fsi] : 10;
 }
 
 /**
  * returns the charset of the font or QString::null
  */
 QString OFontSelector::fontCharSet() const
 {
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( d->m_font_family_list->currentItem());
 
     return fli ? d->m_fdb. charSets ( fli->family()) [0] : QString::null;
 }
 
 /**
  * Overloaded member function see above
  * @see selectedFont
  */
 bool OFontSelector::selectedFont ( QString &family, QString &style, int &size, QString &charset )
 {
     int ffa = d->m_font_family_list->currentItem();
     int fst = d->m_font_style_list->currentItem();
     int fsi = d->m_font_size_list->currentItem();
 
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( ffa );
 
     if ( fli )
     {
         family = fli->family();
         style = fst >= 0 ? fli->styles() [fst] : QString::null;
         size = fsi >= 0 ? fli->sizes() [fsi] : 10;
         charset = d->m_fdb. charSets ( fli->family()) [0];
 
         return true;
     }
     else
         return false;
 }
 
 void OFontSelector::loadFonts ( QListBox *list )
 {
     QStringList f = d->m_fdb. families();
 
     for ( QStringList::ConstIterator it = f. begin(); it != f. end(); ++it )
     {
         QValueList <int> ps = d->m_fdb. pointSizes ( *it );
 
         if ( d->m_pointbug )
         {
             for ( QValueList <int>::Iterator it = ps. begin(); it != ps. end(); it++ )
                 *it /= 10;
         }
 
         list->insertItem ( new FontListItem ( *it, d->m_fdb. styles ( *it ), ps ));
     }
 }
 
 void OFontSelector::fontFamilyClicked ( int index )
 {
     QString oldstyle = d->m_font_style_list->currentText();
     QString oldsize  = d->m_font_size_list->currentText();
 
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( index );
 
     d->m_font_style_list->clear();
     d->m_font_style_list->insertStringList ( fli->styles());
     d->m_font_style_list->setEnabled ( !fli->styles(). isEmpty());
 
     int i;
 
     i = findItemCB ( d->m_font_style_list, oldstyle );
     if ( i < 0 )
         i = findItemCB ( d->m_font_style_list, "Regular" );
     if (( i < 0 ) && ( d->m_font_style_list->count() > 0 ))
         i = 0;
 
     if ( i >= 0 )
     {
         d->m_font_style_list->setCurrentItem ( i );
         fontStyleClicked ( i );
     }
 
     d->m_font_size_list->clear();
     QValueList<int> sl = fli->sizes();
 
     for ( QValueList<int>::Iterator it = sl. begin(); it != sl. end(); ++it )
         d->m_font_size_list->insertItem ( QString::number ( *it ));
 
     i = findItemCB ( d->m_font_size_list, oldsize );
     if ( i < 0 )
         i = findItemCB ( d->m_font_size_list, "10" );
     if (( i < 0 ) && ( d->m_font_size_list->count() > 0 ))
         i = 0;
 
     if ( i >= 0 )
     {
         d->m_font_size_list->setCurrentItem ( i );
         fontSizeClicked ( i );
     }
     changeFont();
 }
 
 void OFontSelector::fontStyleClicked ( int /*index*/ )
 {
     changeFont();
 }
 
 void OFontSelector::fontSizeClicked ( int /*index*/ )
 {
     changeFont();
 }
 
 void OFontSelector::changeFont()
 {
     QFont f = selectedFont();
 
     if ( d->m_preview )
         d->m_preview->setFont ( f );
 
     emit fontSelected ( f );
 }
 
 /**
  * Return the selected font
  */
 QFont OFontSelector::selectedFont()
 {
     int ffa = d->m_font_family_list->currentItem();
     int fst = d->m_font_style_list->currentItem();
     int fsi = d->m_font_size_list->currentItem();
 
     FontListItem *fli = (FontListItem *) d->m_font_family_list->item ( ffa );
 
     if ( fli )
     {
         return d->m_fdb. font ( fli->family(), \
                                  fst >= 0 ? fli->styles() [fst] : QString::null, \
                                  fsi >= 0 ? fli->sizes() [fsi] : 10, \
                                  d->m_fdb. charSets ( fli->family()) [0] );
     }
     else
         return QFont();
 }
 
 void OFontSelector::resizeEvent ( QResizeEvent *re )
 {
     if ( d->m_preview )
     {
         d->m_preview->setMinimumHeight ( 1 );
         d->m_preview->setMaximumHeight ( 32767 );
     }
 
     QWidget::resizeEvent ( re );
 
     if ( d->m_preview )
         d->m_preview->setFixedHeight ( d->m_preview->height());
 
 }
diff --git a/libopie2/opieui/otabwidget.cpp b/libopie2/opieui/otabwidget.cpp
index ec6af9d..f47c90b 100644
--- a/libopie2/opieui/otabwidget.cpp
+++ b/libopie2/opieui/otabwidget.cpp
@@ -1,423 +1,423 @@
 /*
                             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.
 
 */
 
 #include <opie2/otabwidget.h>
 
 /* OPIE */
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qpe/resource.h>
 #include <opie2/otabbar.h>
 
 /* QT */
 #include <qcombobox.h>
 #include <qwidgetstack.h>
 
 using namespace Opie;
 
 OTabWidget::OTabWidget( QWidget *parent, const char *name, TabStyle s, TabPosition p )
         : QWidget( parent, name )
 {
     if ( s == Global )
     {
         Config config( "qpe" );
         config.setGroup( "Appearance" );
         s = ( TabStyle ) config.readNumEntry( "TabStyle", (int) IconTab );
         if ( s <= Global || s > IconList)
         {
             s = IconTab;
         }
         QString pos = config.readEntry( "TabPosition", "Top");
         if ( pos == "Bottom" )
         {
             p = Bottom;
         }
         else
         {
             p = Top;
         }
     }
 
     widgetStack = new QWidgetStack( this, "widgetstack" );
     widgetStack->setFrameStyle( QFrame::NoFrame );
     widgetStack->setLineWidth( style().defaultFrameWidth() );
 
     tabBarStack = new QWidgetStack( this, "tabbarstack" );
 
     tabBar = new OTabBar( tabBarStack, "tabbar" );
     tabBarStack->addWidget( tabBar, 0 );
-    connect( tabBar, SIGNAL( selected( int ) ), this, SLOT( slotTabBarSelected( int ) ) );
+    connect( tabBar, SIGNAL( selected(int) ), this, SLOT( slotTabBarSelected(int) ) );
 
     tabList = new QComboBox( false, tabBarStack, "tablist" );
     tabBarStack->addWidget( tabList, 1 );
-    connect( tabList, SIGNAL( activated( int ) ), this, SLOT( slotTabListSelected( int ) ) );
+    connect( tabList, SIGNAL( activated(int) ), this, SLOT( slotTabListSelected(int) ) );
 
     tabBarPosition = p;
     setTabStyle( s );
     setTabPosition( p );
 
     currTab= 0x0;
 }
 
 OTabWidget::~OTabWidget()
 {}
 
 void OTabWidget::addTab( QWidget *child, const QString &icon, const QString &label )
 {
     QPixmap iconset = loadSmooth( icon );
 
     QTab *tab = new QTab();
     if ( tabBarStyle == IconTab )
     {
         tab->label = QString::null;
     }
     else
     {
         tab->label = label;
     }
     if ( tabBarStyle == IconTab || tabBarStyle == IconList )
     {
         tab->iconset = new QIconSet( iconset );
     }
     int tabid = tabBar->addTab( tab );
 
     if ( tabBarStyle == IconTab || tabBarStyle == IconList )
     {
         tabList->insertItem( iconset, label, -1 );
     }
     else
     {
         tabList->insertItem( label );
     }
 
     widgetStack->addWidget( child, tabid );
     widgetStack->raiseWidget( child );
     widgetStack->setFrameStyle( QFrame::StyledPanel | QFrame::Raised );
 
     OTabInfo *tabinfo = new OTabInfo( tabid, child, icon, label );
     tabs.append( tabinfo );
     selectTab( tabinfo );
 }
 
 void OTabWidget::removePage( QWidget *childwidget )
 {
     if ( childwidget )
     {
         OTabInfo *tab = tabs.first();
         while ( tab && tab->control() != childwidget )
         {
             tab = tabs.next();
         }
         if ( tab && tab->control() == childwidget )
         {
             tabBar->setTabEnabled( tab->id(), FALSE );
             tabBar->removeTab( tabBar->tab( tab->id() ) );
             int i = 0;
             while ( i < tabList->count() && tabList->text( i ) != tab->label() )
             {
                 i++;
             }
             if ( tabList->text( i ) == tab->label() )
             {
                 tabList->removeItem( i );
             }
             widgetStack->removeWidget( childwidget );
             tabs.remove( tab );
             delete tab;
             currTab = tabs.current();
             if ( !currTab )
             {
                 widgetStack->setFrameStyle( QFrame::NoFrame );
             }
 
             setUpLayout();
         }
     }
 }
 
 void OTabWidget::changeTab( QWidget *widget, const QString &iconset, const QString &label)
 {
     OTabInfo *currtab = tabs.first();
     while ( currtab && currtab->control() != widget )
     {
         currtab = tabs.next();
     }
     if ( currtab && currtab->control() == widget )
     {
         QTab *tab = tabBar->tab( currtab->id() );
         QPixmap icon( loadSmooth( iconset ) );
         tab->setText( label );
         if ( tabBarStyle == IconTab )
             tab->setIconSet( icon );
         int i = 0;
         while ( i < tabList->count() && tabList->text( i ) != currtab->label() )
         {
             i++;
         }
         if ( i < tabList->count() && tabList->text( i ) == currtab->label() )
         {
             if ( tabBarStyle == IconTab || tabBarStyle == IconList )
             {
                 tabList->changeItem( icon, label, i );
             }
             else
             {
                 tabList->changeItem( label, i );
             }
         }
         currtab->setLabel( label );
         currtab->setIcon( iconset );
     }
     setUpLayout();
 }
 
 void OTabWidget::setCurrentTab( QWidget *childwidget )
 {
     OTabInfo *currtab = tabs.first();
     while ( currtab && currtab->control() != childwidget )
     {
         currtab = tabs.next();
     }
     if ( currtab && currtab->control() == childwidget )
     {
         selectTab( currtab );
     }
 }
 
 void OTabWidget::setCurrentTab( const QString &tabname )
 {
     OTabInfo *newtab = tabs.first();
     while ( newtab && newtab->label() != tabname )
     {
         newtab = tabs.next();
     }
     if ( newtab && newtab->label() == tabname )
     {
         selectTab( newtab );
     }
 }
 
 void OTabWidget::setCurrentTab(int tabindex)
 {
     OTabInfo *newtab = tabs.first();
     while ( newtab && newtab->id() != tabindex )
     {
         newtab = tabs.next();
     }
     if ( newtab && newtab->id() == tabindex )
     {
         selectTab( newtab );
     }
 }
 
 
 OTabWidget::TabStyle OTabWidget::tabStyle() const
 {
     return tabBarStyle;
 }
 
 void OTabWidget::setTabStyle( TabStyle s )
 {
     tabBarStyle = s;
     if ( tabBarStyle == TextTab || tabBarStyle == IconTab )
     {
         QTab *currtab;
         for (  OTabInfo *tabinfo = tabs.first(); tabinfo; tabinfo = tabs.next() )
         {
             currtab = tabBar->tab( tabinfo->id() );
             if ( tabBarStyle == IconTab )
             {
                 currtab->iconset = new QIconSet( loadSmooth( tabinfo->icon() ) );
                 if ( tabinfo == currTab )
                     currtab->setText( tabinfo->label() );
                 else
                     currtab->setText( QString::null );
             }
             else
             {
                 currtab->iconset = 0x0;
                 currtab->setText( tabinfo->label() );
             }
         }
         tabBarStack->raiseWidget( tabBar );
     }
     else if ( tabBarStyle == TextList || tabBarStyle == IconList )
     {
         tabList->clear();
         for (  OTabInfo *tabinfo = tabs.first(); tabinfo; tabinfo = tabs.next() )
         {
             if ( tabBarStyle == IconList )
             {
                 tabList->insertItem( loadSmooth( tabinfo->icon() ), tabinfo->label() );
             }
             else
             {
                 tabList->insertItem( tabinfo->label() );
             }
         }
         tabBarStack->raiseWidget( tabList );
     }
     setUpLayout();
 }
 
 OTabWidget::TabPosition OTabWidget::tabPosition() const
 {
     return tabBarPosition;
 }
 
 void OTabWidget::setTabPosition( TabPosition p )
 {
     tabBarPosition = p;
     if ( tabBarPosition == Top )
     {
         tabBar->setShape( QTabBar::RoundedAbove );
     }
     else
     {
         tabBar->setShape( QTabBar::RoundedBelow );
     }
     setUpLayout();
 }
 
 void OTabWidget::slotTabBarSelected( int id )
 {
     OTabInfo *newtab = tabs.first();
     while ( newtab && newtab->id() != id )
     {
         newtab = tabs.next();
     }
     if ( newtab && newtab->id() == id )
     {
         selectTab( newtab );
     }
 }
 
 void OTabWidget::slotTabListSelected( int index )
 {
     OTabInfo *newtab = tabs.at( index );
     if ( newtab )
     {
         selectTab( newtab );
     }
 }
 
 QPixmap OTabWidget::loadSmooth( const QString &name )
 {
     QPixmap p;
     p.convertFromImage( Resource::loadImage( name ).smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() ) );
     return p;
 }
 
 void OTabWidget::selectTab( OTabInfo *tab )
 {
     if ( tabBarStyle == IconTab )
     {
         if ( currTab )
         {
             tabBar->tab( currTab->id() )->setText( QString::null );
             setUpLayout();
         }
         tabBar->tab( tab->id() )->setText( tab->label() );
         tabBar->setCurrentTab( tab->id() );
         setUpLayout();
         tabBar->update();
     }
     else
     {
         tabBar->setCurrentTab( tab->id() );
     }
 
     widgetStack->raiseWidget( tab->control() );
 
     emit currentChanged( tab->control() );
 
     currTab = tab;
 }
 
 void OTabWidget::setUpLayout()
 {
     tabBar->layoutTabs();
     QSize t( tabBarStack->sizeHint() );
     if ( tabBarStyle == IconTab )
     {
         if ( t.width() > width() )
             t.setWidth( width() );
     }
     else
     {
         t.setWidth( width() );
     }
     int lw = widgetStack->lineWidth();
     if ( tabBarPosition == Bottom )
     {
         tabBarStack->setGeometry( QMAX(0, lw-2), height() - t.height() - lw, t.width(), t.height() );
         widgetStack->setGeometry( 0, 0, width(), height()-t.height()+QMAX(0, lw-2) );
     }
     else
     {
         tabBarStack->setGeometry( QMAX(0, lw-2), 0, t.width(), t.height() );
         widgetStack->setGeometry( 0, t.height()-lw, width(), height()-t.height()+QMAX( 0, lw-2 ) );
     }
 
     if ( autoMask() )
         updateMask();
 }
 
 QSize OTabWidget::sizeHint() const
 {
     QSize s( widgetStack->sizeHint() );
     QSize t( tabBarStack->sizeHint() );
     return QSize( QMAX( s.width(), t.width() ), s.height() + t.height() );
 }
 
 void OTabWidget::resizeEvent( QResizeEvent * )
 {
     setUpLayout();
 }
 
 int OTabWidget::currentTab()
 {
     if ( currTab )
     {
         return currTab->id();
     }
     return -1;
 }
 
 QWidget* OTabWidget::currentWidget()const
 {
     if ( currTab )
     {
         return currTab->control();
     }
 
     return 0;
 }
diff --git a/libopie2/opieui/otimepicker.cpp b/libopie2/opieui/otimepicker.cpp
index d4712a4..66f9ce0 100644
--- a/libopie2/opieui/otimepicker.cpp
+++ b/libopie2/opieui/otimepicker.cpp
@@ -1,292 +1,292 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) Stefan Eilers <eilers.stefan@epost.de>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 /* QT */
 #include <qlayout.h>
 #include <qlineedit.h>
 
 /* OPIE */
 #include <opie2/otimepicker.h>
 
 using namespace Opie;
 
 /**
  * Constructs the widget
  * @param parent The parent of the OTimePicker
  * @param name The name of the object
  * @param fl Window Flags
  */
 OTimePicker::OTimePicker(QWidget* parent, const char* name, Qt::WFlags fl)
             :QWidget(parent,name,fl)
 {
     QVBoxLayout *vbox=new QVBoxLayout(this);
 
     OClickableLabel *r;
     QString s;
 
     // Hour Row
     QWidget *row=new QWidget(this);
     QHBoxLayout *l=new QHBoxLayout(row);
     vbox->addWidget(row);
 
     for (int i=0; i<24; i++)
     {
         r=new OClickableLabel(row);
         hourLst.append(r);
         s.sprintf("%.2d",i);
         r->setText(s);
         r->setToggleButton(true);
         r->setAlignment(AlignHCenter | AlignVCenter);
         l->addWidget(r);
         connect(r, SIGNAL(toggled(bool)),
                 this, SLOT(slotHour(bool)));
 
         if (i==11)
         { // Second row
             row=new QWidget(this);
             l=new QHBoxLayout(row);
             vbox->addWidget(row);
         }
     }
 
     // Minute Row
     row=new QWidget(this);
     l=new QHBoxLayout(row);
     vbox->addWidget(row);
 
     for (int i=0; i<60; i+=5)
     {
         r=new OClickableLabel(row);
         minuteLst.append(r);
         s.sprintf("%.2d",i);
         r->setText(s);
         r->setToggleButton(true);
         r->setAlignment(AlignHCenter | AlignVCenter);
         l->addWidget(r);
         connect(r, SIGNAL(toggled(bool)),
                 this, SLOT(slotMinute(bool)));
     }
 }
 
 /**
  * This method return the current time
  * @return the time
  */
 QTime OTimePicker::time()const
 {
     return tm;
 }
 
 void OTimePicker::slotHour(bool b)
 {
 
     OClickableLabel *r = (OClickableLabel *) sender();
 
     if (b)
     {
         QValueListIterator<OClickableLabel *> it;
         for (it=hourLst.begin(); it!=hourLst.end(); it++)
         {
             if (*it != r) (*it)->setOn(false);
             else tm.setHMS((*it)->text().toInt(), tm.minute(), 0);
         }
         emit timeChanged(tm);
     }
     else
     {
         r->setOn(true);
     }
 
 }
 
 void OTimePicker::slotMinute(bool b)
 {
 
     OClickableLabel *r = (OClickableLabel *) sender();
 
     if (b)
     {
         QValueListIterator<OClickableLabel *> it;
         for (it=minuteLst.begin(); it!=minuteLst.end(); it++)
         {
             if (*it != r) (*it)->setOn(false);
             else tm.setHMS(tm.hour(),(*it)->text().toInt(), 0);
         }
         emit timeChanged(tm);
     }
     else
     {
         r->setOn(true);
     }
 
 }
 
 /**
  * Method to set the time. No signal gets emitted during this method call
  * Minutes must be within 5 minutes step starting at 0 ( 0,5,10,15,20... )
  * @param t The time to be set
  */
 void OTimePicker::setTime( const QTime& t)
 {
     setTime( t.hour(), t.minute() );
 }
 
 /**
  * Method to set the time. No signal gets emitted during this method call
  * @param h The hour
  * @param m The minute. Minutes need to set by 5 minute steps
  */
 void OTimePicker::setTime( int h,  int m )
 {
     setHour(h);
     setMinute(m);
 }
 
 /*
  * FIXME round minutes to the 5 minute arrangement -zecke
  */
 /**
  * Method to set the minutes
  * @param m minutes
  */
 void OTimePicker::setMinute(int m)
 {
 
     QString minute;
     minute.sprintf("%.2d",m);
 
     QValueListIterator<OClickableLabel *> it;
     for (it=minuteLst.begin(); it!=minuteLst.end(); it++)
     {
         if ((*it)->text() == minute) (*it)->setOn(true);
         else (*it)->setOn(false);
     }
 
     tm.setHMS(tm.hour(),m,0);
 }
 
 /**
  * Method to set the hour
  */
 void OTimePicker::setHour(int h)
 {
 
     QString hour;
     hour.sprintf("%.2d",h);
 
     QValueListIterator<OClickableLabel *> it;
     for (it=hourLst.begin(); it!=hourLst.end(); it++)
     {
         if ((*it)->text() == hour) (*it)->setOn(true);
         else (*it)->setOn(false);
     }
     tm.setHMS(h,tm.minute(),0);
 }
 
 
 /**
  * This is a modal Dialog.
  *
  * @param parent The parent widget
  * @param name The name of the object
  * @param fl Possible window flags
  */
 OTimePickerDialog::OTimePickerDialog ( QWidget* parent, const char* name, WFlags fl )
         : OTimePickerDialogBase (parent , name, true , fl)
 {
 
-    connect ( m_timePicker, SIGNAL( timeChanged( const QTime& ) ),
-              this, SLOT( setTime ( const QTime& ) ) );
-    connect ( minuteField, SIGNAL( textChanged ( const QString& ) ),
-              this, SLOT ( setMinute ( const QString& ) ) );
-    connect ( hourField, SIGNAL( textChanged ( const QString& ) ),
-              this, SLOT ( setHour ( const QString& ) ) );
+    connect ( m_timePicker, SIGNAL( timeChanged(const QTime&) ),
+              this, SLOT( setTime(const QTime&) ) );
+    connect ( minuteField, SIGNAL( textChanged(const QString&) ),
+              this, SLOT ( setMinute(const QString&) ) );
+    connect ( hourField, SIGNAL( textChanged(const QString&) ),
+              this, SLOT ( setHour(const QString&) ) );
 
 }
 
 /**
  * @return the time
  */
 QTime OTimePickerDialog::time()const
 {
     return m_time;
 }
 
 /**
  * Set the time to time
  * @param time The time to be set
  */
 void OTimePickerDialog::setTime( const QTime& time )
 {
     m_time = time;
 
     m_timePicker->setHour ( time.hour() );
     m_timePicker->setMinute( time.minute() );
 
     // Set Textfields
     if ( time.hour() < 10 )
         hourField->setText( "0" + QString::number( time.hour() ) );
     else
         hourField->setText( QString::number( time.hour() ) );
 
     if ( time.minute() < 10 )
         minuteField->setText( "0" + QString::number( time.minute() ) );
     else
         minuteField->setText( QString::number( time.minute() ) );
 
 }
 
 /**
  * This method takes the current minute and tries to set hour
  * to hour. This succeeds if the resulting date is valid
  * @param hour The hour as a string
  */
 void OTimePickerDialog::setHour ( const QString& hour )
 {
     if ( QTime::isValid ( hour.toInt(),  m_time.minute() , 00 ) )
     {
         m_time.setHMS ( hour.toInt(),  m_time.minute() , 00 );
         setTime ( m_time );
     }
 
 }
 
 /**
  * Method to set a new minute. It tries to convert the string to int and
  * if the resulting date is valid a new date is set.
  * @see setHour
  */
 void OTimePickerDialog::setMinute ( const QString& minute )
 {
     if ( QTime::isValid ( m_time.hour(), minute.toInt(), 00 ) )
     {
         m_time.setHMS ( m_time.hour(), minute.toInt(), 00 );
         setTime ( m_time );
     }
 }
diff --git a/libopie2/opieui/oversatileview.cpp b/libopie2/opieui/oversatileview.cpp
index 8839456..78154b7 100644
--- a/libopie2/opieui/oversatileview.cpp
+++ b/libopie2/opieui/oversatileview.cpp
@@ -1,1169 +1,1169 @@
 /*
                              This file is part of the Opie Project
 
               =.             (C) 2003 Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 /* OPIE */
 
 #include <opie2/odebug.h>
 #include <opie2/oversatileview.h>
 #include <opie2/oversatileviewitem.h>
 #include <opie2/olistview.h>
 
 /* QT */
 
 #include <qaction.h>
 #include <qpopupmenu.h>
 
 /* XPM */
 static const char * view_icon_xpm[] = {
 "16 16 16 1",
         " c None",
         ".c #87BD88",
         "+c #8BBE8B",
         "@c #81BA81",
         "#c #6DAF6D",
         "$c #87BD87",
         "%c #FCFDFC",
         "&c #AED0AE",
         "*c #4E9C4C",
         "=c #91BD91",
         "-c #72B172",
         ";c #448643",
         ">c #519F50",
         ",c #499247",
         "'c #356A35",
         ")c #686868",
 "                ",
 "  .+@#    .+@#  ",
 "  $%&*    $%&*  ",
 "  @=-;    @=-;  ",
 "  #>,'    #>,'  ",
 "                ",
 " ))))))  )))))) ",
 "                ",
 "                ",
 "  .+@#    .+@#  ",
 "  $%&*    $%&*  ",
 "  @=-;    @=-;  ",
 "  #>,'    #>,'  ",
 "                ",
 " ))))))  )))))) ",
 "                "};
 
 /* XPM */
 static const char * view_tree_xpm[] = {
 "16 16 17 1",
         " c None",
         ".c #3A3A3A",
         "+c #87BD88",
         "@c #8BBE8B",
         "#c #81BA81",
         "$c #6DAF6D",
         "%c #87BD87",
         "&c #FCFDFC",
         "*c #AED0AE",
         "=c #4E9C4C",
         "-c #91BD91",
         ";c #72B172",
         ">c #448643",
         ",c #686868",
         "'c #519F50",
         ")c #499247",
         "!c #356A35",
 " .              ",
 " .              ",
 " .  +@#$        ",
 " .  %&*=        ",
 " .. #-;>  ,, ,,,",
 " .  $')!        ",
 " .              ",
 " .              ",
 " .              ",
 " .  +@#$        ",
 " .  %&*=        ",
 " .. #-;>  ,, ,,,",
 "    $')!        ",
 "                ",
 "                ",
 "                "};
 
 OVersatileView::OVersatileView( QWidget* parent, const char* name, int mode )
                :QWidgetStack( parent, name ),
                 _viewmode( mode ), _warningpolicy( None ),
                 _treeleaf(), _treeopened(), _treeclosed(),
                 _iconleaf(), _iconopened(), _iconclosed()
 {
     //
     // Create child widgets and set some reasonable default styles
     //
 
     _listview = new OListView( this, "oversatileview embedded listview" );
     _iconview = new QIconView( this, "oversatileview embedded iconview" );
 
     _listview->setAllColumnsShowFocus( true );
     _listview->setRootIsDecorated( true );
     _listview->setShowSortIndicator( true );
     _iconview->setGridX( 90 );
     _iconview->setGridY( 42 );
     _iconview->setAutoArrange( true );
     
     #ifdef QWS  // TODO: Let this depend on current geometry (rotation)
     _iconview->setArrangement( QIconView::TopToBottom );
     #else
     _iconview->setArrangement( QIconView::LeftToRight );
     #endif
     
     _iconview->setResizeMode( QIconView::Adjust );
     
     // qt-embedded: map stylus right on hold to right button press
 
     #ifdef QWS
     ( (QPEApplication*) qApp)->setStylusOperation( _iconview->viewport(), QPEApplication::RightOnHold );
     ( (QPEApplication*) qApp)->setStylusOperation( _listview->viewport(), QPEApplication::RightOnHold );
     #endif
 
     setViewMode( mode ); // TODO: Read last style from config
     // setSynchronization( true ); // TODO: Implement this
 
     // create context menu allowing to switch between the views
 
     _contextmenu = new QPopupMenu( 0, "oversatileview contextmenu" );
     _contextmenu->setCaption( "Style" );
     _contextmenu->setCheckable( true );
     QActionGroup* ag = new QActionGroup( _contextmenu, "style option group" );
     QAction* a1 = new QAction( "View Items in Icon Style", QIconSet( QPixmap( view_icon_xpm ) ),
                                "View Icons", 0, ag, "viewicon action", true );
     QAction* a2 = new QAction( "View Items in Tree Style", QIconSet( QPixmap( view_tree_xpm ) ),
                                 "View Tree", 0, ag, "viewtree action", true );
     ag->addTo( _contextmenu );
     if ( mode == Icons )
         a1->setOn( true );
     else if ( mode == Tree )
         a2->setOn( true );
     connect( a1, SIGNAL( activated() ), this, SLOT( setIconViewMode() ) );
     connect( a2, SIGNAL( activated() ), this, SLOT( setTreeViewMode() ) );
     
     #if (QT_VERSION >= 0x030000)
-    connect( _listview, SIGNAL( contextMenuRequested( QListViewItem*, const QPoint&, int ) ), this, SLOT( contextMenuRequested( QListViewItem*, const QPoint&, int ) ) );
-    connect( _iconview, SIGNAL( contextMenuRequested( QIconViewItem*, const QPoint& ) ), this, SLOT( contextMenuRequested( QIconViewItem*, const QPoint& ) ) );
+    connect( _listview, SIGNAL( contextMenuRequested(QListViewItem*,const QPoint&,int) ), this, SLOT( contextMenuRequested(QListViewItem*,const QPoint&,int) ) );
+    connect( _iconview, SIGNAL( contextMenuRequested(QIconViewItem*,const QPoint&) ), this, SLOT( contextMenuRequested(QIconViewItem*,const QPoint&) ) );
     #else
-    connect( _listview, SIGNAL( rightButtonPressed( QListViewItem*, const QPoint&, int ) ), this, SLOT( contextMenuRequested( QListViewItem*, const QPoint&, int ) ) );
-    connect( _iconview, SIGNAL( rightButtonPressed( QIconViewItem*, const QPoint& ) ), this, SLOT( contextMenuRequested( QIconViewItem*, const QPoint& ) ) );
+    connect( _listview, SIGNAL( rightButtonPressed(QListViewItem*,const QPoint&,int) ), this, SLOT( contextMenuRequested(QListViewItem*,const QPoint&,int) ) );
+    connect( _iconview, SIGNAL( rightButtonPressed(QIconViewItem*,const QPoint&) ), this, SLOT( contextMenuRequested(QIconViewItem*,const QPoint&) ) );
     #endif
         
     //
     // signal forwarders
     //
     // unfortunately we can't short-circuit all the QListView and QIconView signals
     // to OVersatileView signals, because the signal/slot mechanism doesn't allow
     // type-conversion :-(
 
     // common signals for listview
     
     connect( _listview, SIGNAL( selectionChanged() ), this, SIGNAL( selectionChanged() ) );
-    connect( _listview, SIGNAL( selectionChanged( QListViewItem * ) ), this, SLOT( selectionChanged( QListViewItem * ) ) );
-    connect( _listview, SIGNAL( currentChanged( QListViewItem * ) ), this, SLOT( currentChanged( QListViewItem * ) ) );   
-    connect( _listview, SIGNAL( clicked( QListViewItem * ) ), this, SLOT( clicked( QListViewItem * ) ) );
-    connect( _listview, SIGNAL( pressed( QListViewItem * ) ), this, SLOT( pressed( QListViewItem * ) ) );
+    connect( _listview, SIGNAL( selectionChanged(QListViewItem*) ), this, SLOT( selectionChanged(QListViewItem*) ) );
+    connect( _listview, SIGNAL( currentChanged(QListViewItem*) ), this, SLOT( currentChanged(QListViewItem*) ) );   
+    connect( _listview, SIGNAL( clicked(QListViewItem*) ), this, SLOT( clicked(QListViewItem*) ) );
+    connect( _listview, SIGNAL( pressed(QListViewItem*) ), this, SLOT( pressed(QListViewItem*) ) );
     
-    connect( _listview, SIGNAL( doubleClicked( QListViewItem * ) ), this, SLOT( doubleClicked( QListViewItem * ) ) );
-    connect( _listview, SIGNAL( returnPressed( QListViewItem * ) ), this, SLOT( returnPressed( QListViewItem * ) ) );
+    connect( _listview, SIGNAL( doubleClicked(QListViewItem*) ), this, SLOT( doubleClicked(QListViewItem*) ) );
+    connect( _listview, SIGNAL( returnPressed(QListViewItem*) ), this, SLOT( returnPressed(QListViewItem*) ) );
     
-    connect( _listview, SIGNAL( onItem( QListViewItem * ) ), this, SLOT( onItem( QListViewItem * ) ) );
+    connect( _listview, SIGNAL( onItem(QListViewItem*) ), this, SLOT( onItem(QListViewItem*) ) );
     connect( _listview, SIGNAL( onViewport() ), this, SIGNAL( onViewport() ) );
 
     // common signals for iconview
     
     connect( _iconview, SIGNAL( selectionChanged() ), this, SIGNAL( selectionChanged() ) );
-    connect( _iconview, SIGNAL( selectionChanged( QIconViewItem * ) ), this, SLOT( selectionChanged( QIconViewItem * ) ) );
-    connect( _iconview, SIGNAL( currentChanged( QIconViewItem * ) ), this, SLOT( currentChanged( QIconViewItem * ) ) );   
-    connect( _iconview, SIGNAL( clicked( QIconViewItem * ) ), this, SLOT( clicked( QIconViewItem * ) ) );
-    connect( _iconview, SIGNAL( pressed( QIconViewItem * ) ), this, SLOT( pressed( QIconViewItem * ) ) );
+    connect( _iconview, SIGNAL( selectionChanged(QIconViewItem*) ), this, SLOT( selectionChanged(QIconViewItem*) ) );
+    connect( _iconview, SIGNAL( currentChanged(QIconViewItem*) ), this, SLOT( currentChanged(QIconViewItem*) ) );   
+    connect( _iconview, SIGNAL( clicked(QIconViewItem*) ), this, SLOT( clicked(QIconViewItem*) ) );
+    connect( _iconview, SIGNAL( pressed(QIconViewItem*) ), this, SLOT( pressed(QIconViewItem*) ) );
     
-    connect( _iconview, SIGNAL( doubleClicked( QIconViewItem * ) ), this, SLOT( doubleClicked( QIconViewItem * ) ) );
-    connect( _iconview, SIGNAL( returnPressed( QIconViewItem * ) ), this, SLOT( returnPressed( QIconViewItem * ) ) );
+    connect( _iconview, SIGNAL( doubleClicked(QIconViewItem*) ), this, SLOT( doubleClicked(QIconViewItem*) ) );
+    connect( _iconview, SIGNAL( returnPressed(QIconViewItem*) ), this, SLOT( returnPressed(QIconViewItem*) ) );
     
-    connect( _iconview, SIGNAL( onItem( QIconViewItem * ) ), this, SLOT( onItem( QIconViewItem * ) ) );
+    connect( _iconview, SIGNAL( onItem(QIconViewItem*) ), this, SLOT( onItem(QIconViewItem*) ) );
     connect( _iconview, SIGNAL( onViewport() ), this, SIGNAL( onViewport() ) );
     
     // listview only signals
     
-    connect( _listview, SIGNAL( expanded( QListViewItem * ) ), this, SLOT( expanded( QListViewItem * ) ) );
-    connect( _listview, SIGNAL( collapsed( QListViewItem * ) ), this, SLOT( collapsed( QListViewItem * ) ) );
+    connect( _listview, SIGNAL( expanded(QListViewItem*) ), this, SLOT( expanded(QListViewItem*) ) );
+    connect( _listview, SIGNAL( collapsed(QListViewItem*) ), this, SLOT( collapsed(QListViewItem*) ) );
     
     // iconview only signals
     
     connect( _iconview, SIGNAL( moved() ), this, SIGNAL( moved() ) );
 }
 
 OVersatileView::~OVersatileView()
 {
 }
 
 QPopupMenu* OVersatileView::contextMenu() const
 {
     return _contextmenu;
 }
 
 void OVersatileView::contextMenuRequested( QListViewItem* item, const QPoint& pos, int col )
 {
     // can't use QObject::inherits here, because ListViewItems, beit Q, O or K,
     // do not inherit from QObject - assuming here the programmer is
     // disciplined enough to only add OVersatileViewItems to an OVersatileView
     popupContextMenu( static_cast<OVersatileViewItem*>( item ), pos, col );
 }
 
 void OVersatileView::contextMenuRequested( QIconViewItem* item, const QPoint& pos )
 {
     // see above
     popupContextMenu( static_cast<OVersatileViewItem*>( item ), pos, -1 );
 }
 
 void OVersatileView::popupContextMenu( OVersatileViewItem* item, const QPoint& pos, int col )
 {
     if ( !item )
         _contextmenu->exec( pos );
     else
         emit( contextMenuRequested( item, pos, col ) );
 }
 
 void OVersatileView::setSynchronization( bool sync )
 {
     _synchronization = sync;
 }
 
 bool OVersatileView::synchronization()
 {
     return _synchronization;
 }
 
 void OVersatileView::setDefaultPixmaps( int mode, QPixmap& leaf, QPixmap& opened, QPixmap& closed )
 {
     if ( mode == Tree )
     {
         _treeleaf = leaf;
         _treeopened = opened;
         _treeclosed = closed;
     }
     else if ( mode == Icons )
     {
         _iconleaf = leaf;
         _iconopened = opened;
         _iconclosed = closed;
     }
     else
     {
         odebug << "OVersatileView::setDefaultPixmaps(): invalid mode" << oendl;
     }
 }
 
 QIconView* OVersatileView::iconView() const
 {
     return _iconview;
 }
 
 OListView* OVersatileView::listView() const
 {
     return _listview;
 }
 
 void OVersatileView::setViewMode( int mode )
 {
     if ( mode == Tree )
     {
         _viewmode = mode;
         raiseWidget( _listview );
     }
     else if ( mode == Icons )
     {
         _viewmode = mode;
         raiseWidget( _iconview );
     }
     else
     {
         odebug << "OVersatileView::setViewMode(): invalid mode" << oendl;
     }
 }
 
 void OVersatileView::setIconViewMode()
 {
     setViewMode( Icons );
 }
 
 void OVersatileView::setTreeViewMode()
 {
     setViewMode( Tree );
 }
 
 bool OVersatileView::isValidViewMode( int mode ) const
 {
     switch ( _warningpolicy )
     {
         case OVersatileView::None:
         {
             return true;
         }
         case OVersatileView::Warn:
         {
             if ( _viewmode != mode )
             {
                 odebug << "OVersatileView::isValidViewMode(): Requested operation not valid in current mode." << oendl;
                 return true;
             }
         }
         case OVersatileView::WarnReturn:
         {
             if ( _viewmode != mode )
             {
                 odebug << "OVersatileView::isValidViewMode(): Requested operation not valid in current mode." << oendl;
                 return false;
             }
         }
         default:
         {
             owarn << "OVersatileView::isValidViewMode(): Inconsistent object state!" << oendl;
             return true;
         }
     }
 }
 void OVersatileView::setWarningPolicy( int policy ) const
 {
     _warningpolicy = policy;
 }
 bool OVersatileView::warningPolicy() const
 {
     return _warningpolicy;
 }
 //==============================================================================================//
 // Stupid Signal forwarders...
 // Folks, this is why I like python with its dynamic typing:
 // I can code the following dozens of lines C++ in four Python lines...
 //==============================================================================================//
 
 void OVersatileView::selectionChanged( QListViewItem * item )
 {
     emit( selectionChanged( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::selectionChanged( QIconViewItem * item )
 {
     emit( selectionChanged( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::currentChanged( QListViewItem * item )
 {
     emit( currentChanged( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::currentChanged( QIconViewItem * item )
 {
     emit( currentChanged( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::clicked( QListViewItem * item )
 {
     emit( clicked( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::clicked( QIconViewItem * item )
 {
     emit( clicked( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::pressed( QListViewItem * item )
 {
     emit( pressed( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::pressed( QIconViewItem * item )
 {
     emit( pressed( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::doubleClicked( QListViewItem * item )
 {
     emit( doubleClicked( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::doubleClicked( QIconViewItem * item )
 {
     emit( doubleClicked( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::returnPressed( QListViewItem * item )
 {
     emit( returnPressed( static_cast<OVersatileViewItem*>( item ) ) );
 }
   
 void OVersatileView::returnPressed( QIconViewItem * item )
 {
     emit( returnPressed( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::onItem( QListViewItem * item )
 {
     emit( onItem( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::onItem( QIconViewItem * item )
 {
     emit( onItem( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 void OVersatileView::expanded( QListViewItem *item ) // QListView
 {
     //odebug << "OVersatileView::expanded(): opening tree..." << oendl;
     if ( !_treeopened.isNull() )
         item->setPixmap( 0, _treeopened );
     emit( expanded( static_cast<OVersatileViewItem*>( item ) ) );
 }
 void OVersatileView::collapsed( QListViewItem *item ) // QListView
 {
     if ( !_treeclosed.isNull() )
         item->setPixmap( 0, _treeclosed );
     emit( collapsed( static_cast<OVersatileViewItem*>( item ) ) );
 }
 
 //=============================================================================================//
 // OVersatileView Case I - API only existing in QListView or QIconView but not in both!
 //==============================================================================================//
     
 int OVersatileView::treeStepSize() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->treeStepSize();
 }
  void OVersatileView::setTreeStepSize( int size )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setTreeStepSize( size );
 }
 
 QHeader * OVersatileView::header() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return 0;
     }
     return _listview->header();
 }
 
  int OVersatileView::addColumn( const QString &label, int size )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->addColumn( label, size );
 }
 
  int OVersatileView::addColumn( const QIconSet& iconset, const QString &label, int size )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->addColumn( iconset, label, size );
 }
 
 void OVersatileView::removeColumn( int index )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->removeColumn( index );
 }
  void OVersatileView::setColumnText( int column, const QString &label )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setColumnText( column, label );
 }
  void OVersatileView::setColumnText( int column, const QIconSet& iconset, const QString &label )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setColumnText( column, iconset, label );
 }
 QString OVersatileView::columnText( int column ) const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return QString::null;
     }
     return _listview->columnText( column );
 }
  void OVersatileView::setColumnWidth( int column, int width )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setColumnWidth( column, width );
 }
 int OVersatileView::columnWidth( int column ) const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->columnWidth( column );
 }
  void OVersatileView::setColumnWidthMode( int column, WidthMode mode )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setColumnWidth( column, mode );
 }
 int OVersatileView::columns() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->columns();
 }
 
  void OVersatileView::setColumnAlignment( int column, int align )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setColumnAlignment( column, align );
 }
 int OVersatileView::columnAlignment( int column ) const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->columnAlignment( column );
 }
 
 OVersatileViewItem * OVersatileView::itemAt( const QPoint & screenPos ) const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _listview->itemAt( screenPos ) );
 }
 QRect OVersatileView::itemRect( const OVersatileViewItem * item ) const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return QRect( -1, -1, -1, -1 );
     }
     return _listview->itemRect( item );
 }
 int OVersatileView::itemPos( const OVersatileViewItem * item )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->itemPos( item );
 }
 
 bool OVersatileView::isSelected( const OVersatileViewItem * item ) const  // QListView  // also in QIconViewItem but !in QIconView *shrug*
 {
     if ( !isValidViewMode( Tree ) )
     {
         return false;
     }
     return _listview->isSelected( item );
 }
 
  void OVersatileView::setMultiSelection( bool enable )
 {
     _listview->setMultiSelection( enable );
 }
 bool OVersatileView::isMultiSelection() const
 {
     return _listview->isMultiSelection();
 }
 
 OVersatileViewItem * OVersatileView::selectedItem() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _listview->selectedItem() );
 }
  void OVersatileView::setOpen( OVersatileViewItem * item, bool open )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setOpen( item, open );
 }
 bool OVersatileView::isOpen( const OVersatileViewItem * item ) const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return false;
     }
     return _listview->isOpen( item );
 }
 
 OVersatileViewItem * OVersatileView::firstChild() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _listview->firstChild() );
 }
 int OVersatileView::childCount() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->childCount();
 }
 
  void OVersatileView::setAllColumnsShowFocus( bool focus )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setAllColumnsShowFocus( focus );
 }
 bool OVersatileView::allColumnsShowFocus() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return false;
     }
     return _listview->allColumnsShowFocus();
 }
 
  void OVersatileView::setItemMargin( int margin )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
    _listview->setItemMargin( margin );
 }
 int OVersatileView::itemMargin() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return -1;
     }
     return _listview->itemMargin();
 }
 
  void OVersatileView::setRootIsDecorated( bool decorate )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setRootIsDecorated( decorate );
 }
 bool OVersatileView::rootIsDecorated() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return false;
     }
     return _listview->rootIsDecorated();
 }
 
 void OVersatileView::setShowSortIndicator( bool show )  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->setShowSortIndicator( show );
 }
 bool OVersatileView::showSortIndicator() const  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return false;
     }
     return _listview->showSortIndicator();
 }
 
 void OVersatileView::triggerUpdate()  // QListView
 {
     if ( !isValidViewMode( Tree ) )
     {
         return;
     }
     _listview->triggerUpdate();
 }
 
 //
 // only in QIconView
 //
     
 uint OVersatileView::count() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return _iconview->count();
 }
 
 int OVersatileView::index( const OVersatileViewItem *item ) const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return -1;
     }
     return _iconview->index( item );
 }
 
 OVersatileViewItem* OVersatileView::firstItem() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _iconview->firstItem() );
 }
 OVersatileViewItem* OVersatileView::lastItem() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _iconview->lastItem() );
 }
 
 OVersatileViewItem* OVersatileView::findItem( const QPoint &pos ) const // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _iconview->findItem( pos ) );
 }
 OVersatileViewItem* OVersatileView::findItem( const QString &text ) const // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _iconview->findItem( text ) );
 }
 
 OVersatileViewItem* OVersatileView::findFirstVisibleItem( const QRect &r ) const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _iconview->findFirstVisibleItem( r ) );
 }
 OVersatileViewItem* OVersatileView::findLastVisibleItem( const QRect &r ) const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return 0;
     }
     return static_cast<OVersatileViewItem*>( _iconview->findLastVisibleItem( r ) );
 }
 
  void OVersatileView::setGridX( int rx )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setGridX( rx );
 }
  void OVersatileView::setGridY( int ry )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setGridY( ry );
 }
 int OVersatileView::gridX() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return -1;
     }
     return _iconview->gridX();
 }
 int OVersatileView::gridY() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return -1;
     }
     return _iconview->gridY();
 }
  void OVersatileView::setSpacing( int sp )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setSpacing( sp );
 }
 int OVersatileView::spacing() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return -1;
     }
     return _iconview->spacing();
 }
  void OVersatileView::setItemTextPos( QIconView::ItemTextPos pos )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setItemTextPos( pos );
 }
 QIconView::ItemTextPos OVersatileView::itemTextPos() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return (QIconView::ItemTextPos) -1;
     }
     return _iconview->itemTextPos();
 }
  void OVersatileView::setItemTextBackground( const QBrush &b )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setItemTextBackground( b );
 }
 QBrush OVersatileView::itemTextBackground() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return QBrush();
     }
     return _iconview->itemTextBackground();
 }
  void OVersatileView::setArrangement( QIconView::Arrangement am )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setArrangement( am );
 }
 QIconView::Arrangement OVersatileView::arrangement() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return (QIconView::Arrangement) -1;
     }
     return _iconview->arrangement();
 }
  void OVersatileView::setResizeMode( QIconView::ResizeMode am )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setResizeMode( am );
 }
 QIconView::ResizeMode OVersatileView::resizeMode() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return (QIconView::ResizeMode) -1;
     }
     return _iconview->resizeMode();
 }
  void OVersatileView::setMaxItemWidth( int w )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setMaxItemWidth( w );
 }
 int OVersatileView::maxItemWidth() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return -1;
     }
     return _iconview->maxItemWidth();
 }
  void OVersatileView::setMaxItemTextLength( int w )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setMaxItemTextLength( w );
 }
 int OVersatileView::maxItemTextLength() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return -1;
     }
     return _iconview->maxItemTextLength();
 }
  void OVersatileView::setAutoArrange( bool b )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setAutoArrange( b );
 }
 bool OVersatileView::autoArrange() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return false;
     }
     return _iconview->autoArrange();
 }
  void OVersatileView::setShowToolTips( bool b )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setShowToolTips( b );
 }
 bool OVersatileView::showToolTips() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return false;
     }
     return _iconview->showToolTips();
 }
 
 bool OVersatileView::sorting() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return false;
     }
     return _iconview->sorting();
 }
 bool OVersatileView::sortDirection() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return false;
     }
     return _iconview->sortDirection();
 }
 
  void OVersatileView::setItemsMovable( bool b )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setItemsMovable( b );
 }
 bool OVersatileView::itemsMovable() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return false;
     }
     return _iconview->itemsMovable();
 }
 void OVersatileView::setWordWrapIconText( bool b )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->setWordWrapIconText( b );
 }
 bool OVersatileView::wordWrapIconText() const  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return false;
     }
     return _iconview->wordWrapIconText();
 }
 
 void OVersatileView::arrangeItemsInGrid( const QSize &grid, bool update )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->arrangeItemsInGrid( grid, update );
 }
 void OVersatileView::arrangeItemsInGrid( bool update )  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->arrangeItemsInGrid( update );
 }
 void OVersatileView::updateContents()  // QIconView
 {
     if ( !isValidViewMode( Icons ) )
     {
         return;
     }
     _iconview->updateContents();
 }
 
 //==============================================================================================//
 // OVersatileView Case II - QListView / QIconView common API
 //==============================================================================================//
 
 void OVersatileView::clear()
 {
     _iconview->clear();
     _listview->clear();
 }
 
 void OVersatileView::setFont( const QFont & font )
 {
     _iconview->setFont( font );
     _listview->setFont( font );
 }
 void OVersatileView::setPalette( const QPalette & palette )
 {
     _iconview->setPalette( palette );
     _listview->setPalette( palette );
 }
 
 void OVersatileView::takeItem( OVersatileViewItem * item )
 {
     _iconview->takeItem( item );
     _listview->takeItem( item );
 }
 
 void OVersatileView::setSelectionMode( SelectionMode mode )
 {
     _iconview->setSelectionMode( (QIconView::SelectionMode) mode );
     _listview->setSelectionMode( (QListView::SelectionMode) mode );
 }
 OVersatileView::SelectionMode OVersatileView::selectionMode() const
 {
     return (OVersatileView::SelectionMode) _iconview->selectionMode();
 }
 
 void OVersatileView::selectAll( bool select )
 {
     _iconview->selectAll( select );
 }
 void OVersatileView::clearSelection()
 {
     _iconview->clearSelection();
     _listview->clearSelection();
 }
 void OVersatileView::invertSelection()
 {
     _iconview->invertSelection();
     _listview->invertSelection();
 }
 
 void OVersatileView::ensureItemVisible( const OVersatileViewItem * item )
 {
     _iconview->ensureItemVisible( const_cast<OVersatileViewItem*>( item ) );
     _listview->ensureItemVisible( item );
 }
 void OVersatileView::repaintItem( const OVersatileViewItem * item ) const
 {
     _iconview->repaintItem( const_cast<OVersatileViewItem*>( item ) );
     _listview->repaintItem( item );
 }
 
 void OVersatileView::setCurrentItem( OVersatileViewItem * item )
 {
     _iconview->setCurrentItem( item );
     _listview->setCurrentItem( item );
 }
 OVersatileViewItem * OVersatileView::currentItem() const
 {
     return static_cast<OVersatileViewItem*>( _listview->currentItem() );
 }
 
 // bool eventFilter( QObject * o, QEvent * )   // use QWidgetStack implementation
 
 // QSize minimumSizeHint() const               // use QWidgetStack implementation
 // QSizePolicy sizePolicy() const              // use QWidgetStack implementation
 // QSize sizeHint() const                      // use QWidgetStack implementation
 
 //==============================================================================================//
 // OVersatileView Case III - APIs which differ slightly
 //==============================================================================================//
 
 /*
 
  void OVersatileView::insertItem( OVersatileViewItem * )  // QListView
  void OVersatileView::insertItem( OVersatileViewItem *item, OVersatileViewItem *after = 0L )  // QIconView
 
  void OVersatileView::setSelected( OVersatileViewItem *, bool )  // QListView
  void OVersatileView::setSelected( OVersatileViewItem *item, bool s, bool cb = FALSE )  // QIconView
 
  void OVersatileView::setSorting( int column, bool increasing = TRUE )  // QListView
 void OVersatileView::setSorting( bool sort, bool ascending = TRUE )  // QIconView
 
 void OVersatileView::sort() // #### make  in next major release  // QListView
  void OVersatileView::sort( bool ascending = TRUE )  // QIconView
 
 */