13 files changed, 11 insertions, 45 deletions

diff --git a/library/alarmserver.cpp b/library/alarmserver.cpp
index 177a0cb..02bca3d 100644
--- a/library/alarmserver.cpp
+++ b/library/alarmserver.cpp
@@ -1,403 +1,401 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qdir.h>
 #include <qfile.h>
 #include <qmessagebox.h>
 #include <qtextstream.h>
 
 
 #include <qpe/qpeapplication.h>
 #include "global.h"
 #include "resource.h"
 
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #include <qpe/qcopenvelope_qws.h>
-#endif
 #include "alarmserver.h"
 #include <qpe/timeconversion.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #include <stdlib.h>
 #include <unistd.h>
 
 struct timerEventItem {
     time_t UTCtime;
     QCString channel, message;
     int data;
     bool operator==( const timerEventItem &right ) const
     {
         return ( UTCtime == right.UTCtime
                  && channel == right.channel
                  && message == right.message
                  && data == right.data );
     }
 };
 
 class TimerReceiverObject : public QObject
 {
 public:
   TimerReceiverObject() { }
   ~TimerReceiverObject() { }
   void resetTimer();
   void setTimerEventItem();
   void deleteTimer();
 protected:
   void timerEvent( QTimerEvent *te );
 private:
     QString atfilename;
 };
 
 TimerReceiverObject *timerEventReceiver = NULL;
 QList<timerEventItem> timerEventList;
 timerEventItem *nearestTimerEvent = NULL;
 
 
 // set the timer to go off on the next event in the list
 void setNearestTimerEvent()
 {
     nearestTimerEvent = NULL;
     QListIterator<timerEventItem> it( timerEventList );
     if ( *it )
         nearestTimerEvent = *it;
     for ( ; *it; ++it )
         if ( (*it)->UTCtime < nearestTimerEvent->UTCtime )
             nearestTimerEvent = *it;
     if (nearestTimerEvent)
         timerEventReceiver->resetTimer();
     else
         timerEventReceiver->deleteTimer();
 }
 
 
 //store current state to file
 //Simple implementation. Should run on a timer.
 
 static void saveState()
 {
     QString savefilename = Global::applicationFileName( "AlarmServer", "saveFile" );
     if ( timerEventList.isEmpty() ) {
         unlink( savefilename );
         return;
     }
 
     QFile savefile(savefilename+".new");
     if ( savefile.open(IO_WriteOnly) ) {
         QDataStream ds( &savefile );
 
         //save
 
         QListIterator<timerEventItem> it( timerEventList );
         for ( ; *it; ++it ) {
             ds << it.current()->UTCtime;
             ds << it.current()->channel;
             ds << it.current()->message;
             ds << it.current()->data;
         }
 
 
         savefile.close();
         unlink( savefilename );
         QDir d; d.rename(savefilename+".new",savefilename);
 
     }
 }
 
 /*!
   Sets up the alarm server. Restoring to previous state (session management).
  */
 void AlarmServer::initialize()
 {
     //read autosave file and put events in timerEventList
 
     QString savefilename = Global::applicationFileName( "AlarmServer", "saveFile" );
 
     QFile savefile(savefilename);
     if ( savefile.open(IO_ReadOnly) ) {
         QDataStream ds( &savefile );
         while ( !ds.atEnd() ) {
             timerEventItem *newTimerEventItem = new timerEventItem;
             ds >> newTimerEventItem->UTCtime;
             ds >> newTimerEventItem->channel;
             ds >> newTimerEventItem->message;
             ds >> newTimerEventItem->data;
             timerEventList.append( newTimerEventItem );
         }
         savefile.close();
         if (!timerEventReceiver)
             timerEventReceiver = new TimerReceiverObject;
         setNearestTimerEvent();
     }
 }
 
 
 
 
 static const char* atdir = "/var/spool/at/";
 
 static bool triggerAtd( bool writeHWClock = FALSE )
 {
     QFile trigger(QString(atdir) + "trigger");
     if ( trigger.open(IO_WriteOnly|IO_Raw) ) {
 
         const char* data =
 #ifdef QT_QWS_CUSTOM
         //custom atd only writes HW Clock if we write a 'W'
             ( writeHWClock ) ? "W\n" :
 #endif
             data = "\n";
         int len = strlen(data);
         int total_written = trigger.writeBlock(data,len);
         if ( total_written != len ) {
             QMessageBox::critical( 0, QObject::tr( "Out of Space" ),
                                    QObject::tr( "Unable to schedule alarm.\nFree some memory and try again." ) );
             trigger.close();
             QFile::remove( trigger.name() );
             return FALSE;
         }
         return TRUE;
     }
     return FALSE;
 }
 
 void TimerReceiverObject::deleteTimer()
 {
     if ( !atfilename.isEmpty() ) {
         unlink( atfilename );
         atfilename = QString::null;
         triggerAtd( FALSE );
     }
 }
 
 void TimerReceiverObject::resetTimer()
 {
     const int maxsecs = 2147000;
     int total_written;
     QDateTime nearest = TimeConversion::fromUTC(nearestTimerEvent->UTCtime);
     QDateTime now = QDateTime::currentDateTime();
     if ( nearest < now )
         nearest = now;
     int secs = TimeConversion::secsTo( now, nearest );
     if ( secs > maxsecs ) {
         // too far for millisecond timing
         secs = maxsecs;
     }
 
     // System timer (needed so that we wake from deep sleep),
     // from the Epoch in seconds.
     //
     int at_secs = TimeConversion::toUTC(nearest);
     // qDebug("reset timer to %d seconds from Epoch",at_secs);
     QString fn = atdir + QString::number(at_secs) + "."
                  + QString::number(getpid());
     if ( fn != atfilename ) {
         QFile atfile(fn+".new");
         if ( atfile.open(IO_WriteOnly|IO_Raw) ) {
             // just wake up and delete the at file
             QString cmd = "#!/bin/sh\nrm " + fn;
             total_written = atfile.writeBlock(cmd.latin1(),cmd.length());
             if ( total_written != int(cmd.length()) ) {
                 QMessageBox::critical( 0, tr("Out of Space"),
                                        tr("Unable to schedule alarm.\n"
                                           "Please free up space and try again") );
                 atfile.close();
                 QFile::remove( atfile.name() );
                 return;
             }
             atfile.close();
             unlink( atfilename );
             QDir d; d.rename(fn+".new",fn);
             chmod(fn.latin1(),0755);
             atfilename = fn;
             triggerAtd( FALSE );
         } else {
             qWarning("Cannot open atd file %s",fn.latin1());
         }
     }
     // Qt timers (does the actual alarm)
     // from now in milliseconds
     //
     qDebug("AlarmServer waiting %d seconds",secs);
     startTimer( 1000 * secs + 500 );
 }
 
 void TimerReceiverObject::timerEvent( QTimerEvent * )
 {
     bool needSave = FALSE;
     killTimers();
     if (nearestTimerEvent) {
         if ( nearestTimerEvent->UTCtime
              <= TimeConversion::toUTC(QDateTime::currentDateTime()) ) {
 #ifndef QT_NO_COP
             QCopEnvelope e( nearestTimerEvent->channel,
                             nearestTimerEvent->message );
             e << TimeConversion::fromUTC( nearestTimerEvent->UTCtime )
               << nearestTimerEvent->data;
 #endif
             timerEventList.remove( nearestTimerEvent );
             needSave = TRUE;
         }
         setNearestTimerEvent();
     } else {
         resetTimer();
     }
     if ( needSave )
         saveState();
 }
 
 /*!
   \class AlarmServer alarmserver.h
   \brief The AlarmServer class allows alarms to be scheduled and unscheduled.
 
     Applications can schedule alarms with addAlarm() and can
     unschedule alarms with deleteAlarm(). When the time for an alarm
     to go off is reached the specified \link qcop.html QCop\endlink
     message is sent on the specified channel (optionally with
     additional data).
 
     Scheduling an alarm using this class is important (rather just using
     a QTimer) since the machine may be asleep and needs to get woken up using
     the Linux kernel which implements this at the kernel level to minimize
     battery usage while asleep.
 
     \ingroup qtopiaemb
     \sa QCopEnvelope
 */
 
 /*!
   Schedules an alarm to go off at (or soon after) time \a when. When
   the alarm goes off, the \link qcop.html QCop\endlink \a message will
   be sent to \a channel, with \a data as a parameter.
 
   If this function is called with exactly the same data as a previous
   call the subsequent call is ignored, so there is only ever one alarm
   with a given set of parameters.
 
   \sa deleteAlarm()
 */
 void AlarmServer::addAlarm ( QDateTime when, const QCString& channel,
                              const QCString& message, int data)
 {
     if ( qApp->type() == QApplication::GuiServer ) {
         bool needSave = FALSE;
         // Here we are the server so either it has been directly called from
         // within the server or it has been sent to us from a client via QCop
         if (!timerEventReceiver)
             timerEventReceiver = new TimerReceiverObject;
 
         timerEventItem *newTimerEventItem = new timerEventItem;
         newTimerEventItem->UTCtime = TimeConversion::toUTC( when );
         newTimerEventItem->channel = channel;
         newTimerEventItem->message = message;
         newTimerEventItem->data = data;
         // explore the case of already having the event in here...
         QListIterator<timerEventItem> it( timerEventList );
         for ( ; *it; ++it )
             if ( *(*it) == *newTimerEventItem )
                 return;
         // if we made it here, it is okay to add the item...
         timerEventList.append( newTimerEventItem );
         needSave = TRUE;
         // quicker than using setNearestTimerEvent()
         if ( nearestTimerEvent ) {
             if (newTimerEventItem->UTCtime < nearestTimerEvent->UTCtime) {
                 nearestTimerEvent = newTimerEventItem;
                 timerEventReceiver->killTimers();
                 timerEventReceiver->resetTimer();
             }
         } else {
             nearestTimerEvent = newTimerEventItem;
             timerEventReceiver->resetTimer();
         }
         if ( needSave )
             saveState();
     } else {
 #ifndef QT_NO_COP
         QCopEnvelope e( "QPE/System", "addAlarm(QDateTime,QCString,QCString,int)" );
         e << when << channel << message << data;
 #endif
     }
 }
 
 /*!
   Deletes previously scheduled alarms which match \a when, \a channel,
   \a message, and \a data.
 
   Passing null values for \a when, \a channel, or for the \link
   qcop.html QCop\endlink \a message, acts as a wildcard meaning "any".
   Similarly, passing -1 for \a data indicates "any".
 
   If there is no matching alarm, nothing happens.
 
   \sa addAlarm()
 
 */
 void AlarmServer::deleteAlarm (QDateTime when, const QCString& channel, const QCString& message, int data)
 {
     if ( qApp->type() == QApplication::GuiServer) {
         bool needSave = FALSE;
         if ( timerEventReceiver != NULL ) {
             timerEventReceiver->killTimers();
 
             // iterate over the list of events
             QListIterator<timerEventItem> it( timerEventList );
             time_t deleteTime = TimeConversion::toUTC( when );
             for ( ; *it; ++it ) {
                 // if its a match, delete it
                 if ( ( (*it)->UTCtime == deleteTime || when.isNull() )
                     && ( channel.isNull() || (*it)->channel == channel )
                     && ( message.isNull() || (*it)->message == message )
                     && ( data==-1 || (*it)->data == data ) )
                 {
                     // if it's first, then we need to update the timer
                     if ( (*it) == nearestTimerEvent ) {
                         timerEventList.remove(*it);
                         setNearestTimerEvent();
                     } else {
                         timerEventList.remove(*it);
                     }
                     needSave = TRUE;
                 }
             }
             if ( nearestTimerEvent )
                 timerEventReceiver->resetTimer();
         }
         if ( needSave )
             saveState();
     } else {
 #ifndef QT_NO_COP
         QCopEnvelope e( "QPE/System", "deleteAlarm(QDateTime,QCString,QCString,int)" );
         e << when << channel << message << data;
 #endif
     }
 }
 
 /*!
   Writes the system clock to the hardware clock.
 */
 void Global::writeHWClock()
 {
     if ( !triggerAtd( TRUE ) ) {
         // atd not running? set it ourselves
         system("/sbin/hwclock --systohc"); // ##### UTC?
     }
 }
diff --git a/library/applnk.cpp b/library/applnk.cpp
index a56da5d..5763c62 100644
--- a/library/applnk.cpp
+++ b/library/applnk.cpp
@@ -1,1480 +1,1476 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_MIMEEXT
 #define QTOPIA_INTERNAL_PRELOADACCESS
 #define QTOPIA_INTERNAL_APPLNKASSIGN
 
 #include "applnk.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/categories.h>
 #include <qpe/categoryselect.h>
-#ifdef QWS
 #include <qpe/qcopenvelope_qws.h>
-#endif
 #include <qpe/global.h>
 #include <qpe/mimetype.h>
 #include <qpe/config.h>
 #include <qpe/storage.h>
 #include <qpe/resource.h>
 
 #include <qdict.h>
 #include <qdir.h>
 #include <qregexp.h>
 
-#ifdef Q_WS_QWS
 #include <qgfx_qws.h>
-#endif
 
 #include <stdlib.h>
 
 int AppLnk::lastId = 5000;
 
 static int smallSize = 14;
 static int bigSize = 32;
 
 static QString safeFileName(const QString& n)
 {
     QString safename=n;
     safename.replace(QRegExp("[^0-9A-Za-z.]"),"_");
     safename.replace(QRegExp("^[^A-Za-z]*"),"");
     if ( safename.isEmpty() )
         safename = "_";
     return safename;
 }
 
 static bool prepareDirectories(const QString& lf)
 {
     if ( !QFile::exists(lf) ) {
         // May need to create directories
         QFileInfo fi(lf);
         if ( system(("mkdir -p "+fi.dirPath(TRUE))) )
             return FALSE;
     }
     return TRUE;
 }
 
 class AppLnkPrivate
 {
 public:
     /* the size of the Pixmap */
     enum Size {Normal = 0, Big };
     AppLnkPrivate() {
         /* we want one normal and one big item */
 
         QPixmap pix;
         mPixmaps.insert(0, pix );
         mPixmaps.insert(1,  pix);
     }
 
     QStringList mCatList; // always correct
     QArray<int> mCat; // cached value; correct if not empty
     QMap<int,  QPixmap> mPixmaps;
 
     void updateCatListFromArray()
     {
         Categories cat( 0 );
         cat.load( categoryFileName() );
         mCatList = cat.labels("Document View",mCat);
     }
 
     void setCatArrayDirty()
     {
         mCat.resize(0);
     }
 
     void ensureCatArray()
     {
         if ( mCat.count() > 0 || mCatList.count()==0 )
             return;
 
         Categories cat( 0 );
         cat.load( categoryFileName() );
         mCat.resize( mCatList.count() );
         int i;
         QStringList::ConstIterator it;
         for ( i = 0, it = mCatList.begin(); it != mCatList.end();
               ++it, i++ ) {
 
             bool number;
             int id = (*it).toInt( &number );
             if ( !number ) {
                 id = cat.id( "Document View", *it );
                 if ( id == 0 )
                     id = cat.addCategory( "Document View", *it );
             }
             mCat[i] = id;
         }
     }
 };
 
 /*!
   \class AppLnk applnk.h
   \brief The AppLnk class represents an application available on the system.
 
     Every Qtopia application \e app has a corresponding \e app.desktop
     file. When one of these files is read its data is stored as an
     AppLnk object.
 
     The AppLnk class introduces some Qtopia-specific concepts, and
     provides a variety of functions, as described in the following
     sections.
     \tableofcontents
 
     \target Types
     \section1 Types
 
     Every AppLnk object has a \e type. For applications, games and
     settings the type is \c Application; for documents the
     type is the document's MIME type.
 
     \target files-and-links
     \section1 Files and Links
 
     When you create an AppLnk (or more likely, a \link doclnk.html
     DocLnk\endlink), you don't deal directly with filenames in the
     filesystem. Instead you do this:
     \code
     DocLnk d;
     d.setType("text/plain");
     d.setName("My Nicely Named Document / Whatever"); // Yes, "/" is legal.
     \endcode
     At this point, the file() and linkFile() are unknown. Normally
     this is uninteresting, and the names become automatically known,
     and more importantly, becomes reserved, when you ask what they are:
 
     \code
     QString fn = d.file();
     \endcode
     This invents a filename, and creates the file on disk (an empty
     reservation file) to prevent the name being used by another
     application.
 
     In some circumstances, you don't want to create the file if it
     doesn't already exist (e.g. in the Document tab, some of the \link
     doclnk.html DocLnk\endlink objects represented by icons are
     DocLnk's created just for that view - they don't have
     corresponding \c .desktop files. To avoid littering empty
     reservation files around, we check in a few places to see whether
     the file really needs to exist).
 
     \section1 Functionality
 
     AppLnk objects are created by calling the constructor with the
     name of a \e .desktop file. The object can be checked for validity
     using isValid().
 
     The following functions are used to set or retrieve information
     about the application:
     \table
     \header \i Get Function \i Set Function \i Short Description
             \row \i \l name()    \i \l setName()    \i application's name
             \row \i \l pixmap()     \i \e none    \i application's icon
             \row \i \l bigPixmap()  \i \e none    \i application's large icon
             \row \i \e none    \i setIcon()    \i sets the icon's filename
             \row \i \l type()     \i \l setType()    \i see \link #Types Types\endlink above
             \row \i \l rotation()   \i \e none    \i 0, 90, 180 or 270 degrees
     \row \i \l comment()    \i \l setComment() \i text for the Details dialog
             \row \i \l exec()    \i \l setExec()    \i executable's filename
             \row \i \l file()       \i \e none    \i document's filename
             \row \i \l linkFile()   \i \l setLinkFile()\i \e .desktop filename
             \row \i \l mimeTypes()  \i \e none    \i the mime types the application can view or edit
             \row \i \l categories() \i \l setCategories()\i \e{see the function descriptions}
             \row \i \l fileKnown()  \i \e none    \i see \link
 #files-and-links Files and Links\endlink above
             \row \i \l linkFileKnown() \i \e none    \i see \link
 #files-and-links Files and Links\endlink above
             \row \i \l property()   \i \l setProperty()\i any AppLnk property
     can be retrieved or set (if writeable) using these
     \endtable
 
     To save an AppLnk to disk use writeLink(). To execute the
     application that the AppLnk object refers to, use execute().
 
     AppLnk's can be deleted from disk using removeLinkFile(). To
     remove both the link and the application's executable use
     removeFiles().
 
     Icon sizes can be globally changed (but only for AppLnk objects
     created after the calls) with setSmallIconSize() and
     setBigIconSize().
 
     \ingroup qtopiaemb
 */
 
 /*!
   Sets the size used for small icons to \a small pixels.
   Only affects AppLnk objects created after the call.
 
   \sa smallIconSize() setIcon()
 */
 void AppLnk::setSmallIconSize(int small)
 {
     smallSize = small;
 }
 
 /*!
   Returns the size used for small icons.
 
   \sa setSmallIconSize() setIcon()
 */
 int AppLnk::smallIconSize()
 {
     return smallSize;
 }
 
 
 /*!
   Sets the size used for large icons to \a big pixels.
   Only affects AppLnk objects created after the call.
 
   \sa bigIconSize() setIcon()
 */
 void AppLnk::setBigIconSize(int big)
 {
     bigSize = big;
 }
 
 /*!
   Returns the size used for large icons.
 
   \sa setBigIconSize() setIcon()
 */
 int AppLnk::bigIconSize()
 {
     return bigSize;
 }
 
 
 /*!
   \fn QString AppLnk::name() const
 
   Returns the Name property. This is the user-visible name for the
   document or application, not the filename.
 
     See \link #files-and-links Files and Links\endlink.
 
   \sa setName()
 */
 /*!
     \fn QString AppLnk::exec() const
 
   Returns the Exec property. This is the name of the executable
   program associated with the AppLnk.
 
   \sa setExec()
 */
 /*!
     \fn QString AppLnk::rotation() const
 
   Returns the Rotation property. The value is 0, 90, 180 or 270
   degrees.
 */
 /*!
     \fn QString AppLnk::comment() const
 
   Returns the Comment property.
 
   \sa setComment()
 */
 /*!
     \fn QStringList AppLnk::mimeTypes() const
 
   Returns the MimeTypes property. This is the list of MIME types
   that the application can view or edit.
 */
 /*!
     \fn const QArray<int>& AppLnk::categories() const
 
   Returns the Categories property.
 
   See the CategoryWidget for more details.
 
   \sa setCategories()
 */
 
 const QArray<int>& AppLnk::categories() const
 {
     d->ensureCatArray();
     return d->mCat;
 }
 
 /*!
     \fn int AppLnk::id() const
 
   Returns the id of the AppLnk. If the AppLnk is not in an AppLnkSet,
   this value is 0, otherwise it is a value that is unique for the
   duration of the current process.
 
   \sa AppLnkSet::find()
 */
 
 /*!
   \fn bool AppLnk::isValid() const
 
   Returns TRUE if this AppLnk is valid; otherwise returns FALSE.
 */
 
 /*!
   Creates an invalid AppLnk.
 
   \sa isValid()
 */
 AppLnk::AppLnk()
 {
     mId = 0;
     d = new AppLnkPrivate();
 }
 
 /*!
   Loads \a file (e.g. \e app.desktop) as an AppLnk.
 
   \sa writeLink()
 */
 AppLnk::AppLnk( const QString &file )
 {
     QStringList sl;
     d = new AppLnkPrivate();
     if ( !file.isNull() ) {
         Config config( file, Config::File );
 
         if ( config.isValid() ) {
             config.setGroup( "Desktop Entry" );
 
             mName = config.readEntry( "Name", file );
             mExec = config.readEntry( "Exec" );
             mType = config.readEntry( "Type", QString::null );
             mIconFile = config.readEntry( "Icon", QString::null );
             mRotation = config.readEntry( "Rotation", "" );
             mComment = config.readEntry( "Comment", QString::null );
             // MIME types are case-insensitive.
             mMimeTypes = config.readListEntry( "MimeType", ';' );
             for (QStringList::Iterator it=mMimeTypes.begin(); it!=mMimeTypes.end(); ++it)
                 *it = (*it).lower();
             mMimeTypeIcons = config.readListEntry( "MimeTypeIcons", ';' );
             mLinkFile = file;
             mFile = config.readEntry("File", QString::null);
             if ( !mExec. isEmpty ( )) {
                 mFile = QString::null;
             }
             else if ( mFile[0] != '/' ) {
                 int slash = file.findRev('/');
                 if ( slash >= 0 ) {
                     mFile = file.left(slash) + '/' + mFile;
                 }
             }
             d->mCatList = config.readListEntry("Categories", ';');
             if ( d->mCatList[0].toInt() < -1 ) {
                 // numeric cats in file! convert to text
                 Categories cat( 0 );
                 cat.load( categoryFileName() );
                 d->mCat.resize( d->mCatList.count() );
                 int i;
                 QStringList::ConstIterator it;
                 for ( i = 0, it = d->mCatList.begin(); it != d->mCatList.end();
                       ++it, i++ ) {
                     bool number;
                     int id = (*it).toInt( &number );
                     if ( !number ) {
                         // convert from text
                         id = cat.id( "Document View", *it );
                         if ( id == 0 )
                             id = cat.addCategory( "Document View", *it );
                     }
                     d->mCat[i] = id;
                 }
                 d->updateCatListFromArray();
             }
         }
     }
     mId = 0;
 }
 
 AppLnk& AppLnk::operator=(const AppLnk &copy)
 {
     if ( mId )
         qWarning("Deleting AppLnk that is in an AppLnkSet");
     if ( d )
         delete d;
 
 
     mName = copy.mName;
 
     /* remove for Qtopia 3.0 -zecke */
     mPixmap = copy.mPixmap;
     mBigPixmap = copy.mBigPixmap;
 
     mExec = copy.mExec;
     mType = copy.mType;
     mRotation = copy.mRotation;
     mComment = copy.mComment;
     mFile = copy.mFile;
     mLinkFile = copy.mLinkFile;
     mIconFile = copy.mIconFile;
     mMimeTypes = copy.mMimeTypes;
     mMimeTypeIcons = copy.mMimeTypeIcons;
     mId = 0;
     d = new AppLnkPrivate();
     d->mCat = copy.d->mCat;
     d->mCatList = copy.d->mCatList;
     d->mPixmaps = copy.d->mPixmaps;
 
     return *this;
 }
 /*!
   protected internally to share code
   should I document that at all?
   I don't know the TT style for that
 */
 const QPixmap& AppLnk::pixmap( int pos, int size ) const {
     if ( d->mPixmaps[pos].isNull() ) {
         AppLnk* that = (AppLnk*)this;
         if ( mIconFile.isEmpty() ) {
             MimeType mt(type());
             that->d->mPixmaps[pos] = mt.pixmap();
             if ( that->d->mPixmaps[pos].isNull() )
                 that->d->mPixmaps[pos].convertFromImage(
                     Resource::loadImage("UnknownDocument")
                         .smoothScale( size, size ) );
             return that->d->mPixmaps[pos];
         }
         QImage unscaledIcon = Resource::loadImage( that->mIconFile );
         if ( unscaledIcon.isNull() ) {
             qDebug( "Cannot find icon: %s", that->mIconFile.latin1() );
             that->d->mPixmaps[pos].convertFromImage(
                     Resource::loadImage("UnknownDocument")
                         .smoothScale( size, size ) );
         } else {
             that->d->mPixmaps[0].convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
             that->d->mPixmaps[1].convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
         }
         return that->d->mPixmaps[pos];
     }
     return d->mPixmaps[pos];
 }
 
 /*!
   Returns a small pixmap associated with the application.
 
   \sa bigPixmap() setIcon()
 */
 const QPixmap& AppLnk::pixmap() const
 {
     if ( d->mPixmaps[0].isNull() ) {
         return pixmap(AppLnkPrivate::Normal, smallSize );
     }
     return d->mPixmaps[0];
 }
 
 /*!
   Returns a large pixmap associated with the application.
 
   \sa pixmap() setIcon()
 */
 const QPixmap& AppLnk::bigPixmap() const
 {
     if ( d->mPixmaps[1].isNull() ) {
         return pixmap( AppLnkPrivate::Big, bigSize );
     }
     return d->mPixmaps[1];
 }
 
 /*!
   Returns the type of the AppLnk. For applications, games and
   settings the type is \c Application; for documents the type is the
   document's MIME type.
 */
 QString AppLnk::type() const
 {
     if ( mType.isNull() ) {
         AppLnk* that = (AppLnk*)this;
         QString f = file();
         if ( !f.isNull() ) {
             MimeType mt(f);
             that->mType = mt.id();
             return that->mType;
         }
     }
     return mType;
 }
 
 /*!
   Returns the file associated with the AppLnk.
 
   \sa exec() name()
 */
 QString AppLnk::file() const
 {
     if ( mExec.isEmpty ( ) && mFile.isNull() ) {
         AppLnk* that = (AppLnk*)this;
         QString ext = MimeType(mType).extension();
         if ( !ext.isEmpty() )
             ext = "." + ext;
         if ( !mLinkFile.isEmpty() ) {
             that->mFile =
                 mLinkFile.right(8)==".desktop" // 8 = strlen(".desktop")
                     ? mLinkFile.left(mLinkFile.length()-8) : mLinkFile;
         qDebug("mFile now == %s", mFile.latin1());
         } else if ( mType.contains('/') ) {
             that->mFile =
                 QString(getenv("HOME"))+"/Documents/"+mType+"/"+safeFileName(that->mName);
             /*
              * A file with the same name or a .desktop file already exists
              */
             if ( QFile::exists(that->mFile+ext) || QFile::exists(that->mFile+".desktop") ) {
                 int n=1;
                 QString nn;
                 while (QFile::exists((nn=(that->mFile+"_"+QString::number(n)))+ext)
                         || QFile::exists(nn+".desktop"))
                     n++;
                 that->mFile = nn;
             }
             that->mLinkFile = that->mFile+".desktop";
             that->mFile += ext;
         }
         prepareDirectories(that->mFile);
         if ( !that->mFile.isEmpty() ) {
             QFile f(that->mFile);
             if ( !f.open(IO_WriteOnly) )
                 that->mFile = QString::null;
             return that->mFile;
         }
     }
     return mFile;
 }
 
 /*!
   Returns the desktop file corresponding to this AppLnk.
 
   \sa file() exec() name()
 */
 QString AppLnk::linkFile() const
 {
     if ( mLinkFile.isNull() ) {
         AppLnk* that = (AppLnk*)this;
         if ( type().contains('/') ) {
             StorageInfo storage;
             const FileSystem *fs = storage.fileSystemOf( that->mFile );
             /* tmpfs + and ramfs are available too but not removable
              * either we fix storage or add this
              */
             if ( fs && ( fs->isRemovable() || fs->disk() == "/dev/mtdblock6" || fs->disk() == "tmpfs") ) {
                 that->mLinkFile = fs->path();
             } else
                 that->mLinkFile = getenv( "HOME" );
             that->mLinkFile += "/Documents/"+type()+"/"+safeFileName(that->mName);
 
             /* the desktop file exists make sure we don't point to the same file */
             if ( QFile::exists(that->mLinkFile+".desktop") ) {
                 AppLnk lnk( that->mLinkFile + ".desktop" );
 
                 /* the linked is different */
                 if(that->file() != lnk.file() ) {
                     int n = 1;
                     QString nn;
                     while (QFile::exists((nn=that->mLinkFile+"_"+QString::number(n))+".desktop")) {
                         n++;
                         /* just to be sure */
                         AppLnk lnk(nn );
                         if (lnk.file() == that->file() )
                             break;
                     }
                     that->mLinkFile = nn;
                 }
             }
             that->mLinkFile += ".desktop";
             storeLink();
         }
         return that->mLinkFile;
     }
     return mLinkFile;
 }
 
 /*!
   Copies \a copy.
 */
 AppLnk::AppLnk( const AppLnk &copy )
 {
     mName = copy.mName;
     mPixmap = copy.mPixmap;
     mBigPixmap = copy.mBigPixmap;
     mExec = copy.mExec;
     mType = copy.mType;
     mRotation = copy.mRotation;
     mComment = copy.mComment;
     mFile = copy.mFile;
     mLinkFile = copy.mLinkFile;
     mIconFile = copy.mIconFile;
     mMimeTypes = copy.mMimeTypes;
     mMimeTypeIcons = copy.mMimeTypeIcons;
     mId = 0;
     d = new AppLnkPrivate();
     d->mCat = copy.d->mCat;
     d->mCatList = copy.d->mCatList;
     d->mPixmaps = copy.d->mPixmaps;
 }
 
 /*!
   Destroys the AppLnk. Note that if the AppLnk is currently a member
   of an AppLnkSet, this will produce a run-time warning.
 
   \sa AppLnkSet::add() AppLnkSet::remove()
 */
 AppLnk::~AppLnk()
 {
     if ( mId )
         qWarning("Deleting AppLnk that is in an AppLnkSet");
     if ( d )
         delete d;
 }
 
 /*!
   \overload
   Executes the application associated with this AppLnk.
 
   \sa exec()
 */
 void AppLnk::execute() const
 {
     execute(QStringList());
 }
 
 /*!
   Executes the application associated with this AppLnk, with
   \a args as arguments.
 
   \sa exec()
 */
 void AppLnk::execute(const QStringList& args) const
 {
 #ifdef Q_WS_QWS
     if ( !mRotation.isEmpty() ) {
         // ######## this will only work in the server
         int rot = QPEApplication::defaultRotation();
         rot = (rot+mRotation.toInt())%360;
         QCString old = getenv("QWS_DISPLAY");
         setenv("QWS_DISPLAY", QString("Transformed:Rot%1:0").arg(rot), 1);
         invoke(args);
         setenv("QWS_DISPLAY", old.data(), 1);
     } else
 #endif
         invoke(args);
 }
 
 /*!
   Invokes the application associated with this AppLnk, with
   \a args as arguments. Rotation is not taken into account by
   this function, so you should not call it directly.
 
   \sa execute()
 */
 void AppLnk::invoke(const QStringList& args) const
 {
     Global::execute( exec(), args[0] );
 }
 
 /*!
   Sets the Exec property to \a exec.
 
   \sa exec() name()
 */
 void AppLnk::setExec( const QString& exec )
 {
     mExec = exec;
 }
 
 #if 0 // this was inlined for better BC
 /*!
   Sets the Rotation property to \a rot.
 
   \sa rotation()
 */
 void AppLnk::setRotation ( const QString &rot )
 {
         mRotation = rot;
 }
 #endif
 
 /*!
   Sets the Name property to \a docname.
 
   \sa name()
 */
 void AppLnk::setName( const QString& docname )
 {
     mName = docname;
 }
 
 /*!
   Sets the File property to \a filename.
 
   \sa file() name()
 */
 void AppLnk::setFile( const QString& filename )
 {
     mFile = filename;
 }
 
 /*!
   Sets the LinkFile property to \a filename.
 
   \sa linkFile()
 */
 void AppLnk::setLinkFile( const QString& filename )
 {
     mLinkFile = filename;
 }
 
 /*!
   Sets the Comment property to \a comment.
 
   This text is displayed in the 'Details Dialog', for example if the
   user uses the 'press-and-hold' gesture.
 
   \sa comment()
 */
 void AppLnk::setComment( const QString& comment )
 {
     mComment = comment;
 }
 
 /*!
   Sets the Type property to \a type.
 
   For applications, games and settings the type should be \c
   Application; for documents the type should be the document's MIME
   type.
 
   \sa type()
 */
 void AppLnk::setType( const QString& type )
 {
     mType = type;
 }
 
 /*!
   \fn QString AppLnk::icon() const
 
   Returns the Icon property.
 
   \sa setIcon()
 */
 
 /*!
   Sets the Icon property to \a iconname. This is the filename from
   which the pixmap() and bigPixmap() are obtained.
 
   \sa icon() setSmallIconSize() setBigIconSize()
 */
 void AppLnk::setIcon( const QString& iconname )
 {
     mIconFile = iconname;
     QImage unscaledIcon = Resource::loadImage( mIconFile );
     d->mPixmaps[0].convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
     d->mPixmaps[1].convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
 }
 
 /*!
   Sets the Categories property to \a c.
 
   See the CategoryWidget for more details.
 
   \sa categories()
 */
 void AppLnk::setCategories( const QArray<int>& c )
 {
     d->mCat = c;
     d->updateCatListFromArray();
 }
 
 /*!
   \fn QStringList AppLnk::mimeTypeIcons() const
 
   Returns the MimeTypeIcons property of the AppLnk.
 */
 
 /*!
   Attempts to ensure that the link file for this AppLnk exists,
   including creating any required directories. Returns TRUE if
   successful; otherwise returns FALSE.
 
   You should not need to use this function.
 */
 bool AppLnk::ensureLinkExists() const
 {
     QString lf = linkFile();
     return prepareDirectories(lf);
 }
 
 /*!
   Commits the AppLnk to disk. Returns TRUE if the operation succeeded;
   otherwise returns FALSE.
 
   In addition, the "linkChanged(QString)" message is sent to the
   "QPE/System" \link qcop.html QCop\endlink channel.
 */
 bool AppLnk::writeLink() const
 {
     // Only re-writes settable parts
     QString lf = linkFile();
     if ( !ensureLinkExists() )
         return FALSE;
     storeLink();
     return TRUE;
 }
 
 /*!
   \internal
 */
 void AppLnk::storeLink() const
 {
     Config config( mLinkFile, Config::File );
     config.setGroup("Desktop Entry");
     config.writeEntry("Name",mName);
     if ( !mIconFile.isNull() ) config.writeEntry("Icon",mIconFile);
     config.writeEntry("Type",type());
     if(!rotation().isEmpty())
         config.writeEntry("Rotation",rotation());
     else
         config.removeEntry("Rotation");    
     if ( !mComment.isNull() ) config.writeEntry("Comment",mComment);
     QString f = file();
     int i = 0;
     while ( i < (int)f.length() && i < (int)mLinkFile.length() && f[i] == mLinkFile[i] )
         i++;
     while ( i && f[i] != '/' )
         i--;
     // simple case where in the same directory
     if ( mLinkFile.find( '/', i + 1 ) < 0 )
         f = f.mid(i+1);
     // ### could do relative ie ../../otherDocs/file.doc
     config.writeEntry("File",f);
     config.writeEntry( "Categories", d->mCatList, ';' );
 
 #ifndef QT_NO_COP
     QCopEnvelope e("QPE/System", "linkChanged(QString)");
     e << mLinkFile;
 #endif
 }
 
 /*!
   Sets the property named \a key to \a value.
 
   \sa property()
 */
 void AppLnk::setProperty(const QString& key, const QString& value)
 {
     if ( ensureLinkExists() ) {
         Config cfg(linkFile(), Config::File);
         cfg.writeEntry(key,value);
     }
 }
 
 /*!
   Returns the property named \a key.
 
   \sa setProperty()
 */
 QString AppLnk::property(const QString& key) const
 {
     QString lf = linkFile();
     if ( !QFile::exists(lf) )
         return QString::null;
     Config cfg(lf, Config::File);
     return cfg.readEntry(key);
 }
 
 bool AppLnk::isPreloaded() const {
   // Preload information is stored in the Launcher config in v1.5.
   Config cfg("Launcher");
   cfg.setGroup("Preload");
   QStringList apps = cfg.readListEntry("Apps",',');
   if (apps.contains(exec()))
     return true;
   return false;
 }
 
 void AppLnk::setPreloaded(bool yesNo) {
   // Preload information is stored in the Launcher config in v1.5.
   Config cfg("Launcher");
   cfg.setGroup("Preload");
   QStringList apps = cfg.readListEntry("Apps", ',');
   if (apps.contains(exec()) && !yesNo)
     apps.remove(exec());
   else if (yesNo && !apps.contains(exec()))
     apps.append(exec());
   cfg.writeEntry("Apps", apps, ',');
 }
 
 
 /*!
   Deletes both the linkFile() and the file() associated with this AppLnk.
 
   \sa removeLinkFile()
 */
 void AppLnk::removeFiles()
 {
     bool valid = isValid();
     if ( !valid || !linkFileKnown() || QFile::remove(linkFile()) ) {
         if ( QFile::remove(file()) ) {
 #ifndef QT_NO_COP
             QCopEnvelope e("QPE/System", "linkChanged(QString)");
             if ( linkFileKnown() )
                 e << linkFile();
             else
                 e << file();
 #endif
         } else if ( valid ) {
             // restore link
             writeLink();
         }
     }
 }
 
 /*!
   Deletes the linkFile(), leaving any file() untouched.
 
     \sa removeFiles()
 */
 void AppLnk::removeLinkFile()
 {
     if ( isValid() && linkFileKnown() && QFile::remove(linkFile()) ) {
 #ifndef QT_NO_COP
         QCopEnvelope e("QPE/System", "linkChanged(QString)");
         e << linkFile();
 #endif
     }
 }
 
 class AppLnkSetPrivate {
 public:
     AppLnkSetPrivate()
     {
         typPix.setAutoDelete(TRUE);
         typPixBig.setAutoDelete(TRUE);
         typName.setAutoDelete(TRUE);
     }
 
     QDict<QPixmap> typPix;
     QDict<QPixmap> typPixBig;
     QDict<QString> typName;
 };
 
 /*!
   \class AppLnkSet applnk.h
   \brief The AppLnkSet class is a set of AppLnk objects.
 */
 
 /*!
   \fn QStringList AppLnkSet::types() const
 
   Returns the list of \link applnk.html#Types types\endlink in the set.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 
   \sa AppLnk::type(), typeName(), typePixmap(), typeBigPixmap()
 */
 
 /*!
   \fn const QList<AppLnk>& AppLnkSet::children() const
 
   Returns the members of the set.
 */
 
 /*!
   Constructs an empty AppLnkSet.
 */
 AppLnkSet::AppLnkSet() :
     d(new AppLnkSetPrivate)
 {
 }
 
 /*!
   Constructs an AppLnkSet that contains AppLnk objects representing
   all the files in the given \a directory (and any subdirectories
   recursively).
 
   \omit
   The directories may contain ".directory" files which override
   any AppLnk::type() values for AppLnk objects found in the directory.
   This allows simple localization of application types.
   \endomit
 */
 AppLnkSet::AppLnkSet( const QString &directory ) :
     d(new AppLnkSetPrivate)
 {
     QDir dir( directory );
     mFile = directory;
     findChildren(directory,QString::null,QString::null);
 }
 
 /*!
   Detaches all AppLnk objects from the set. The set become empty and
   the caller becomes responsible for deleting the AppLnk objects.
 */
 void AppLnkSet::detachChildren()
 {
     QListIterator<AppLnk> it( mApps );
     for ( ; it.current(); ) {
         AppLnk* a = *it;
         ++it;
         a->mId = 0;
     }
     mApps.clear();
 }
 
 /*!
   Destroys the set, deleting all the AppLnk objects it contains.
 
   \sa detachChildren()
 */
 AppLnkSet::~AppLnkSet()
 {
     QListIterator<AppLnk> it( mApps );
     for ( ; it.current(); ) {
         AppLnk* a = *it;
         ++it;
         a->mId = 0;
         delete a;
     }
     delete d;
 }
 
 void AppLnkSet::findChildren(const QString &dr, const QString& typ, const QString& typName, int depth)
 {
     depth++;
     if ( depth > 10 )
         return;
 
     QDir dir( dr );
     QString typNameLocal = typName;
 
     if ( dir.exists( ".directory" ) ) {
         Config config( dr + "/.directory", Config::File );
         config.setGroup( "Desktop Entry" );
         typNameLocal = config.readEntry( "Name", typNameLocal );
         if ( !typ.isEmpty() ) {
             QString iconFile = config.readEntry( "Icon", "AppsIcon" );
             QImage unscaledIcon = Resource::loadImage( iconFile );
             QPixmap pm, bpm;
             pm.convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
             bpm.convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
             d->typPix.insert(typ, new QPixmap(pm));
             d->typPixBig.insert(typ, new QPixmap(bpm));
             d->typName.insert(typ, new QString(typNameLocal));
         }
     }
 
     const QFileInfoList *list = dir.entryInfoList();
     if ( list ) {
         QFileInfo* fi;
         bool cadded=FALSE;
         for ( QFileInfoListIterator it(*list); (fi=*it); ++it ) {
             QString bn = fi->fileName();
             if ( bn[0] != '.' && bn != "CVS" ) {
                 if ( fi->isDir() ) {
                     QString c = typ.isNull() ? bn : typ+"/"+bn;
                     QString d = typNameLocal.isNull() ? bn : typNameLocal+"/"+bn;
                     findChildren(fi->filePath(), c, d, depth );
                 } else {
                     if ( fi->extension(FALSE) == "desktop" ) {
                         AppLnk* app = new AppLnk( fi->filePath() );
 #ifdef QT_NO_QWS_MULTIPROCESS
                         if ( !Global::isBuiltinCommand( app->exec() ) )
                             delete app;
                         else
 #endif
                         {
                             if ( !typ.isEmpty() ) {
                                 if ( !cadded ) {
                                     typs.append(typ);
                                     cadded = TRUE;
                                 }
                                 app->setType(typ);
                             }
                             add(app);
                         }
                     }
                 }
             }
         }
     }
 }
 
 /*!
   Adds AppLnk \a f to the set. The set takes responsibility for
   deleting \a f.
 
   \sa remove()
 */
 void AppLnkSet::add( AppLnk *f )
 {
     if ( f->mId == 0 ) {
         AppLnk::lastId++;
         f->mId = AppLnk::lastId;
         mApps.append( f );
     } else {
         qWarning("Attempt to add an AppLnk twice");
     }
 }
 
 /*!
   Removes AppLnk \a f to the set. The caller becomes responsible for
   deleting \a f. Returns TRUE if \a f was in the set; otherwise
   returns FALSE.
 
   \sa add()
 */
 bool AppLnkSet::remove( AppLnk *f )
 {
     if ( mApps.remove( f ) ) {
         f->mId = 0;
         return TRUE;
     }
     return FALSE;
 }
 
 
 /*!
   Returns the localized name for type \a t.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 */
 QString AppLnkSet::typeName( const QString& t ) const
 {
     QString *st = d->typName.find(t);
     return st ? *st : QString::null;
 }
 
 /*!
   Returns the small pixmap associated with type \a t.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 */
 QPixmap AppLnkSet::typePixmap( const QString& t ) const
 {
     QPixmap *pm = d->typPix.find(t);
     return pm ? *pm : QPixmap();
 }
 
 /*!
   Returns the large pixmap associated with type \a t.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 */
 QPixmap AppLnkSet::typeBigPixmap( const QString& t ) const
 {
     QPixmap *pm = d->typPixBig.find(t);
     return pm ? *pm : QPixmap();
 }
 
 /*!
   Returns the AppLnk with the given \a id.
 */
 const AppLnk *AppLnkSet::find( int id ) const
 {
     QListIterator<AppLnk> it( children() );
 
     for ( ; it.current(); ++it ) {
         const AppLnk *app = it.current();
         if ( app->id() == id )
             return app;
     }
 
     return 0;
 }
 
 /*!
   Returns the AppLnk with the given \a exec attribute.
 */
 const AppLnk *AppLnkSet::findExec( const QString& exec ) const
 {
     QListIterator<AppLnk> it( children() );
 
     for ( ; it.current(); ++it ) {
         const AppLnk *app = it.current();
         if ( app->exec() == exec )
             return app;
     }
 
     return 0;
 }
 
 /*!
   \class DocLnkSet applnk.h
   \brief The DocLnkSet class is a set of DocLnk objects.
 */
 
 /*!
   \fn const QList<DocLnk>& DocLnkSet::children() const
 
   Returns the members of the set.
 */
 
 /*!
   Constructs an empty DocLnkSet.
 
   \sa appendFrom()
 */
 DocLnkSet::DocLnkSet()
 {
 }
 
 /*!
   Constructs a DocLnkSet that contains DocLnk objects representing all
   the files in the \a directory (and any subdirectories, recursively).
 
   If \a mimefilter is not null,
   only documents with a MIME type matching \a mimefilter are selected.
   The value may contain multiple wild-card patterns separated by ";",
   such as \c{*o/mpeg;audio/x-wav}.
 
   See also \link applnk.html#files-and-links Files and Links\endlink.
 
 */
 DocLnkSet::DocLnkSet( const QString &directory, const QString& mimefilter ) :
     AppLnkSet()
 {
     QDir dir( directory );
     mFile = dir.dirName();
     QDict<void> reference;
 
     QStringList subFilter = QStringList::split(";", mimefilter);
     QValueList<QRegExp> mimeFilters;
     for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++ it )
         mimeFilters.append( QRegExp(*it, FALSE, TRUE) );
 
     findChildren(directory, mimeFilters, reference);
 
     const QList<DocLnk> &list = children();
     for ( QListIterator<DocLnk> it( list ); it.current(); ++it ) {
         reference.remove( (*it)->file() );
     }
 
     for ( QDictIterator<void> dit(reference); dit.current(); ++dit ) {
         if ( dit.current() == (void*)2 ) {
             // Unreferenced, make an unwritten link
             DocLnk* dl = new DocLnk;
             QFileInfo fi( dit.currentKey() );
             dl->setFile(fi.filePath());
             dl->setName(fi.baseName());
             // #### default to current path?
             // dl->setCategories( ... );
             bool match = mimefilter.isNull();
             if ( !match )
                 for( QValueList<QRegExp>::Iterator it = mimeFilters.begin(); it != mimeFilters.end() && !match; ++ it )
                     if ( (*it).match(dl->type()) >= 0 )
                         match = TRUE;
             if ( match /* && dl->type() != "application/octet-stream" */
                     && !!dl->exec() )
                 add(dl);
             else
                 delete dl;
         }
     }
 }
 
 // other becomes empty
 /*!
   Transfers all DocLnk objects from \a other to this set. \a other becomes
   empty.
 */
 void DocLnkSet::appendFrom( DocLnkSet& other )
 {
     if ( &other == this )
         return;
     QListIterator<AppLnk> it( other.mApps );
     for ( ; it.current(); ) {
         mApps.append(*it);
         ++it;
     }
     other.mApps.clear();
 }
 
 void DocLnkSet::findChildren(const QString &dr, const QValueList<QRegExp> &mimeFilters, QDict<void> &reference, int depth)
 {
     depth++;
     if ( depth > 10 )
         return;
 
     QDir dir( dr );
 
     /* Opie got a different approach
      * I guess it's geek vs. consumer
      * in this case to be discussed
      */
     if ( dir.exists( ".Qtopia-ignore" ) )
         return;
 
     const QFileInfoList *list = dir.entryInfoList();
     if ( list ) {
         QFileInfo* fi;
         for ( QFileInfoListIterator it(*list); (fi=*it); ++it ) {
             QString bn = fi->fileName();
             if ( bn[0] != '.' ) {
                 if ( fi->isDir()  ) {
                     if ( bn != "CVS" && bn != "Qtopia" && bn != "QtPalmtop" )
                         findChildren(fi->filePath(), mimeFilters, reference, depth);
                 } else {
                     if ( fi->extension(FALSE) == "desktop" ) {
                         DocLnk* dl = new DocLnk( fi->filePath() );
                         QFileInfo fi2(dl->file());
                         bool match = FALSE;
                         if ( !fi2.exists() ) {
                             dir.remove( dl->file() );
                         }
                         if ( mimeFilters.count() == 0 ) {
                             add( dl );
                             match = TRUE;
                         } else {
                             for( QValueList<QRegExp>::ConstIterator it = mimeFilters.begin(); it != mimeFilters.end(); ++ it ) {
                                 if ( (*it).match(dl->type()) >= 0 ) {
                                     add(dl);
                                     match = TRUE;
                                 }
                             }
                         }
                         if ( !match )
                             delete dl;
                     } else {
                         if ( !reference.find(fi->fileName()) )
                             reference.insert(fi->filePath(), (void*)2);
                     }
                 }
             }
         }
     }
 }
 
 /*!
   \class DocLnk applnk.h
   \brief The DocLnk class represents loaded document references.
 */
 
 /*!
   \fn DocLnk::DocLnk( const DocLnk &o )
 
   Copies \a o.
 */
 
 /*!
   Constructs a DocLnk from a valid .desktop \a file or a new .desktop
   \a file for other files.
 */
 DocLnk::DocLnk( const QString &file ) :
     AppLnk(file)
 {
     init(file);
 }
 
 /*!
   Constructs a DocLnk from a valid .desktop \a file or a new .desktop
   \a file for other files. If \a may_be_desktopfile is TRUE, then an
   attempt is made to read \a file as a .desktop file; if that fails it
   is read as a normal file.
 */
 DocLnk::DocLnk( const QString &file, bool may_be_desktopfile ) :
     AppLnk(may_be_desktopfile ? file : QString::null)
 {
     init(file);
 }
 
 void DocLnk::init(const QString &file)
 {
     if ( isValid() ) {
 #ifndef FORCED_DIR_STRUCTURE_WAY
         if ( mType.isNull() )
             // try to infer it
 #endif
         {
             int s0 = file.findRev('/');
             if ( s0 > 0 ) {
                 int s1 = file.findRev('/',s0-1);
                 if ( s1 > 0 ) {
                     int s2 = file.findRev('/',s1-1);
                     if ( s2 > 0 ) {
                         mType = file.mid(s2+1,s0-s2-1);
                     }
                 }
             }
         }
     } else if ( QFile::exists(file) ) {
         QString n = file;
         n.replace(QRegExp(".*/"),"");
         n.replace(QRegExp("\\..*"),"");
         setName( n );
         setFile( file );
     }
     MimeType mt(mType);
     if( mt.application() )
         mExec = mt.application()->exec();
 }
 
 /*!
   Constructs an invalid DocLnk.
 */
 DocLnk::DocLnk()
 {
 }
 
 /*!
   Destroys the DocLnk. Just like AppLnk objects, a run-time error
   occurs if the DocLnk is a member of a DocLnkSet (or AppLnkSet).
 */
 DocLnk::~DocLnk()
 {
 }
 
 /*!
   \reimp
 */
 QString DocLnk::exec() const
 {
     MimeType mt(type());
     const AppLnk* app = mt.application();
     if ( app )
         return app->exec();
     else
         return QString::null;
 }
 
 /*!
   \reimp
 */
 void DocLnk::invoke(const QStringList& args) const
 {
     MimeType mt(type());
     const AppLnk* app = mt.application();
     if ( app ) {
         QStringList a = args;
         if ( linkFileKnown() && QFile::exists( linkFile() ) )
             a.append(linkFile());
         else
             a.append(file());
         app->execute(a);
     }
 }
 
 
diff --git a/library/fileselector.cpp b/library/fileselector.cpp
index 052a29e..4039243 100644
--- a/library/fileselector.cpp
+++ b/library/fileselector.cpp
@@ -1,583 +1,581 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 // WARNING: Do *NOT* define this yourself. The SL5xxx from SHARP does NOT
 //      have this class.
 #define QTOPIA_INTERNAL_FSLP
 
 #include "fileselector.h"
 #include "fileselector_p.h"
 #include "global.h"
 #include "resource.h"
 #include "config.h"
 #include "applnk.h"
 #include "storage.h"
 #include "qpemenubar.h"
-#ifdef QWS
 #include <qcopchannel_qws.h>
-#endif
 #include "lnkproperties.h"
 #include "applnk.h"
 #include <qpe/qpeapplication.h>
 #include "categorymenu.h"
 #include "categoryselect.h"
 #include "mimetype.h"
 #include <qpe/categories.h>
 
 #include <stdlib.h>
 
 #include <qdir.h>
 #include <qwidget.h>
 #include <qpopupmenu.h>
 #include <qtoolbutton.h>
 #include <qpushbutton.h>
 #include <qheader.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
 
 class TypeCombo : public QComboBox
 {
     Q_OBJECT
 public:
     TypeCombo( QWidget *parent, const char *name=0 )
         : QComboBox( parent, name )
     {
         connect( this, SIGNAL(activated(int)), this, SLOT(selectType(int)) );
     }
 
     void reread( DocLnkSet &files, const QString &filter );
 
 signals:
     void selected( const QString & );
 
 protected slots:
     void selectType( int idx ) {
         emit selected( typelist[idx] );
     }
 
 protected:
     QStringList typelist;
     QString prev;
 };
 
 void TypeCombo::reread( DocLnkSet &files, const QString &filter )
 {
     typelist.clear();
     QStringList filters = QStringList::split( ';', filter );
     int pos = filter.find( '/' );
     //### do for each filter
     if ( filters.count() == 1 && pos >= 0 && filter[pos+1] != '*' ) {
         typelist.append( filter );
         clear();
         QString minor = filter.mid( pos+1 );
         minor[0] = minor[0].upper();
         insertItem( tr("%1 files").arg(minor) );
         setCurrentItem(0);
         setEnabled( FALSE );
         return;
     }
 
     QListIterator<DocLnk> dit( files.children() );
     for ( ; dit.current(); ++dit ) {
         if ( !typelist.contains( (*dit)->type() ) )
             typelist.append(  (*dit)->type() );
     }
 
     QStringList types;
     QStringList::ConstIterator it;
     for (it = typelist.begin(); it!=typelist.end(); ++it) {
         QString t = *it;
         if ( t.left(12) == "application/" ) {
             MimeType mt(t);
             const AppLnk* app = mt.application();
             if ( app )
                 t = app->name();
             else
                 t = t.mid(12);
         } else {
             QString major, minor;
             int pos = t.find( '/' );
             if ( pos >= 0 ) {
                 major = t.left( pos );
                 minor = t.mid( pos+1 );
             }
             if ( minor.find( "x-" ) == 0 )
                 minor = minor.mid( 2 );
             minor[0] = minor[0].upper();
             major[0] = major[0].upper();
             if ( filters.count() > 1 )
                 t = tr("%1 %2", "minor mimetype / major mimetype").arg(minor).arg(major);
             else
                 t = minor;
         }
         types += tr("%1 files").arg(t);
     }
     for (it = filters.begin(); it!=filters.end(); ++it) {
         typelist.append( *it );
         int pos = (*it).find( '/' );
         if ( pos >= 0 ) {
             QString maj = (*it).left( pos );
             maj[0] = maj[0].upper();
             types << tr("All %1 files").arg(maj);
         }
     }
     if ( filters.count() > 1 ) {
         typelist.append( filter );
         types << tr("All files");
     }
     prev = currentText();
     clear();
     insertStringList(types);
     for (int i=0; i<count(); i++) {
         if ( text(i) == prev ) {
             setCurrentItem(i);
             break;
         }
     }
     if ( prev.isNull() )
         setCurrentItem(count()-1);
     setEnabled( TRUE );
 }
 
 
 //===========================================================================
 
 FileSelectorItem::FileSelectorItem( QListView *parent, const DocLnk &f )
     : QListViewItem( parent ), fl( f )
 {
     setText( 0, f.name() );
     setPixmap( 0, f.pixmap() );
 }
 
 FileSelectorItem::~FileSelectorItem()
 {
 }
 
 FileSelectorView::FileSelectorView( QWidget *parent, const char *name )
     : QListView( parent, name )
 {
     setAllColumnsShowFocus( TRUE );
     addColumn( tr( "Name" ) );
     header()->hide();
 }
 
 FileSelectorView::~FileSelectorView()
 {
 }
 
 void FileSelectorView::keyPressEvent( QKeyEvent *e )
 {
     QString txt = e->text();
     if (e->key() == Key_Space)
         emit returnPressed( currentItem() );
     else if ( !txt.isNull() && txt[0] > ' ' && e->key() < 0x1000 )
         e->ignore();
     else
         QListView::keyPressEvent(e);
 }
 
 class NewDocItem : public FileSelectorItem
 {
 public:
     NewDocItem( QListView *parent, const DocLnk &f )
         : FileSelectorItem( parent, f ) {
         setText( 0, QObject::tr("New Document") );
         QImage img( Resource::loadImage( "new" ) );
         QPixmap pm;
         pm = img.smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() );
         setPixmap( 0, pm );
     }
     QString key ( int, bool ) const {
         return QString("\n");
     }
 
     void paintCell( QPainter *p, const QColorGroup &cg, int column, int width, int alignment ) {
         QFont oldFont = p->font();
         QFont newFont = p->font();
         newFont.setWeight( QFont::Bold );
         p->setFont( newFont );
         FileSelectorItem::paintCell( p, cg, column, width, alignment );
         p->setFont( oldFont );
     }
 
     int width( const QFontMetrics &fm, const QListView *v, int c ) const {
         return FileSelectorItem::width( fm, v, c )*4/3; // allow for bold font
     }
 };
 
 //===========================================================================
 
 class FileSelectorPrivate
 {
 public:
     TypeCombo *typeCombo;
     CategorySelect *catSelect;
     QValueList<QRegExp> mimeFilters;
     int catId;
     bool showNew;
     NewDocItem *newDocItem;
     DocLnkSet files;
     QHBox *toolbar;
 };
 
 /*!
   \class FileSelector fileselector.h
   \brief The FileSelector widget allows the user to select DocLnk objects.
 
   This class presents a file selection dialog to the user. This widget
   is usually the first widget seen in a \link docwidget.html
   document-oriented application\endlink. The developer will most often
   create this widget in combination with a <a
   href="../qt/qwidgetstack.html"> QWidgetStack</a> and the appropriate
   editor and/or viewer widget for their application. This widget
   should be shown first and the user can the select which document
   they wish to operate on. Please refer to the implementation of
   texteditor for an example of how to tie these classes together.
 
   Use setNewVisible() depending on whether the application can be used
   to create new files or not. Use setCloseVisible() depending on
   whether the user may leave the dialog without creating or selecting
   a document or not. The number of files in the view is available from
   fileCount(). To force the view to be updated call reread().
 
   If the user presses the 'New Document' button the newSelected()
   signal is emitted. If the user selects an existing file the
   fileSelected() signal is emitted. The selected file's \link
   doclnk.html DocLnk\endlink is available from the selected()
   function. If the file selector is no longer necessary the closeMe()
   signal is emitted.
 
   \ingroup qtopiaemb
   \sa FileManager
 */
 
 /*!
   Constructs a FileSelector with mime filter \a f.
   The standard Qt \a parent and \a name parameters are passed to the
   parent widget.
 
   If \a newVisible is TRUE, the widget has a button to allow the user
   the create "new" documents; this is useful for applications that can
   create and edit documents but not suitable for applications that
   only provide viewing.
 
   \a closeVisible is deprecated
 
   \sa DocLnkSet::DocLnkSet()
 */
 FileSelector::FileSelector( const QString &f, QWidget *parent, const char *name, bool newVisible, bool closeVisible )
     : QVBox( parent, name ), filter( f )
 {
     setMargin( 0 );
     setSpacing( 0 );
 
     d = new FileSelectorPrivate();
     d->newDocItem = 0;
     d->showNew = newVisible;
     d->catId = -2; // All files
 
     d->toolbar = new QHBox( this );
     d->toolbar->setBackgroundMode( PaletteButton );   // same colour as toolbars
     d->toolbar->setSpacing( 0 );
     d->toolbar->hide();
 
     QWidget *spacer = new QWidget( d->toolbar );
     spacer->setBackgroundMode( PaletteButton );
 
     QToolButton *tb = new QToolButton( d->toolbar );
     tb->setPixmap( Resource::loadPixmap( "close" ) );
     connect( tb, SIGNAL( clicked() ), this, SIGNAL( closeMe() ) );
     buttonClose = tb;
     tb->setFixedSize( 18, 20 ); // tb->sizeHint() );
     tb->setAutoRaise( TRUE );
     QToolTip::add( tb, tr( "Close the File Selector" ) );
     QPEMenuToolFocusManager::manager()->addWidget( tb );
 
     view = new FileSelectorView( this, "fileview" );
     QPEApplication::setStylusOperation( view->viewport(), QPEApplication::RightOnHold );
     connect( view, SIGNAL( mouseButtonClicked( int, QListViewItem *, const QPoint &, int ) ),
              this, SLOT( fileClicked( int, QListViewItem *, const QPoint &, int ) ) );
     connect( view, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint &, int ) ),
              this, SLOT( filePressed( int, QListViewItem *, const QPoint &, int ) ) );
     connect( view, SIGNAL( returnPressed( QListViewItem * ) ),
              this, SLOT( fileClicked( QListViewItem * ) ) );
 
     QHBox *hb = new QHBox( this );
 
     d->typeCombo = new TypeCombo( hb );
     connect( d->typeCombo, SIGNAL(selected(const QString&)),
             this, SLOT(typeSelected(const QString&)) );
     QWhatsThis::add( d->typeCombo, tr("Show documents of this type") );
 
     Categories c;
     c.load(categoryFileName());
     QArray<int> vl( 0 );
     d->catSelect = new CategorySelect( hb );
     d->catSelect->setRemoveCategoryEdit( TRUE );
     d->catSelect->setCategories( vl, "Document View", tr("Document View") );
     d->catSelect->setAllCategories( TRUE );
     connect( d->catSelect, SIGNAL(signalSelected(int)), this, SLOT(catSelected(int)) );
     QWhatsThis::add( d->catSelect, tr("Show documents in this category") );
 
     setCloseVisible( closeVisible );
 
     QCopChannel *channel = new QCopChannel( "QPE/Card", this );
     connect( channel, SIGNAL(received(const QCString &, const QByteArray &)),
             this, SLOT(cardMessage( const QCString &, const QByteArray &)) );
 
     reread();
     updateWhatsThis();
 }
 
 /*!
   Destroys the widget.
 */
 FileSelector::~FileSelector()
 {
     delete d;
 }
 
 /*!
   Returns the number of files in the view. If this is zero, an editor
   application might bypass the selector and immediately start with
   a "new" document.
 */
 int FileSelector::fileCount()
 {
     return d->files.children().count();;
 }
 
 /*!
   Calling this function is the programmatic equivalent of the user
   pressing the "new" button.
 
   \sa newSelected(), closeMe()
 */
 void FileSelector::createNew()
 {
     DocLnk f;
     emit newSelected( f );
     emit closeMe();
 }
 
 void FileSelector::fileClicked( int button, QListViewItem *i, const QPoint &, int )
 {
     if ( !i )
         return;
     if ( button == Qt::LeftButton ) {
         fileClicked( i );
     }
 }
 
 void FileSelector::filePressed( int button, QListViewItem *i, const QPoint &, int )
 {
     if ( !i || i == d->newDocItem )
         return;
     if ( button == Qt::RightButton ) {
         DocLnk l = ((FileSelectorItem *)i)->file();
         LnkProperties prop( &l );
         prop.showMaximized();
         prop.exec();
         reread();
     }
 }
 
 void FileSelector::fileClicked( QListViewItem *i )
 {
     if ( !i )
         return;
     if ( i == d->newDocItem ) {
         createNew();
     } else {
         emit fileSelected( ( (FileSelectorItem*)i )->file() );
         emit closeMe();
     }
 }
 
 void FileSelector::typeSelected( const QString &type )
 {
     d->mimeFilters.clear();
     QStringList subFilter = QStringList::split(";", type);
     for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++it )
         d->mimeFilters.append( QRegExp(*it, FALSE, TRUE) );
     updateView();
 }
 
 void FileSelector::catSelected( int c )
 {
     d->catId = c;
     updateView();
 }
 
 void FileSelector::cardMessage( const QCString &msg, const QByteArray &)
 {
     if ( msg == "mtabChanged()" )
         reread();
 }
 
 
 /*!
   Returns the selected \link doclnk.html DocLnk\endlink. The caller is
   responsible for deleting the returned value.
 */
 const DocLnk *FileSelector::selected()
 {
     FileSelectorItem *item = (FileSelectorItem *)view->selectedItem();
     if ( item && item != d->newDocItem )
         return new DocLnk( item->file() );
     return NULL;
 }
 
 /*!
   \fn void FileSelector::fileSelected( const DocLnk &f )
 
   This signal is emitted when the user selects a document.
   \a f is the document.
 */
 
 /*!
   \fn void FileSelector::newSelected( const DocLnk &f )
 
   This signal is emitted when the user selects a "new" document.
   \a f is a DocLnk for the document. You will need to set the type
   of the document after copying it.
 */
 
 /*!
   \fn void FileSelector::closeMe()
 
   This signal is emitted when the user no longer needs to view the widget.
 */
 
 
 /*!
   If \a b is TRUE a "new document" entry is visible; if \a b is FALSE
   this entry is not visible and the user is unable to create new
   documents from the dialog.
 */
 void FileSelector::setNewVisible( bool b )
 {
     if ( d->showNew != b ) {
         d->showNew = b;
         updateView();
         updateWhatsThis();
     }
 }
 
 /*!
   If \a b is TRUE a "close" or "no document" button is visible; if \a
   b is FALSE this button is not visible and the user is unable to
   leave the dialog without creating or selecting a document.
 
   This function is deprecated.
 */
 void FileSelector::setCloseVisible( bool b )
 {
     if (  b )
         d->toolbar->show();
     else
         d->toolbar->hide();
 }
 
 /*!
 
 */
 void FileSelector::setTypeComboVisible( bool b ) {
     if ( b )
         d->typeCombo->show();
     else
         d->typeCombo->hide();
 }
 /*!
 
 */
 void FileSelector::setCategorySelectVisible( bool b ) {
     if ( b )
         d->catSelect->show();
     else
         d->catSelect->hide();
 }
 
 /*!
   Rereads the list of documents.
 */
 void FileSelector::reread()
 {
     d->files.clear();
     Global::findDocuments(&d->files, filter);
     d->typeCombo->reread( d->files, filter );
     updateView();
 }
 
 void FileSelector::updateView()
 {
     FileSelectorItem *item = (FileSelectorItem *)view->selectedItem();
     if ( item == d->newDocItem )
         item = 0;
     QString oldFile;
     if ( item )
         oldFile = item->file().file();
     view->clear();
     QListIterator<DocLnk> dit( d->files.children() );
     for ( ; dit.current(); ++dit ) {
         bool mimeMatch = FALSE;
         if ( d->mimeFilters.count() ) {
             QValueList<QRegExp>::Iterator it;
             for ( it = d->mimeFilters.begin(); it != d->mimeFilters.end(); ++it ) {
                 if ( (*it).match((*dit)->type()) >= 0 ) {
                     mimeMatch = TRUE;
                     break;
                 }
             }
         } else {
             mimeMatch = TRUE;
         }
         if ( mimeMatch &&
                 (d->catId == -2 || (*dit)->categories().contains(d->catId) ||
                  (d->catId == -1 && (*dit)->categories().isEmpty())) ) {
             item = new FileSelectorItem( view, **dit );
             if ( item->file().file() == oldFile )
                 view->setCurrentItem( item );
         }
     }
 
     if ( d->showNew )
         d->newDocItem = new NewDocItem( view, DocLnk() );
     else
         d->newDocItem = 0;
 
     if ( !view->selectedItem() || view->childCount() == 1 ) {
         view->setCurrentItem( view->firstChild() );
         view->setSelected( view->firstChild(), TRUE );
     }
 }
 
 void FileSelector::updateWhatsThis()
 {
     QWhatsThis::remove( this );
     QString text = tr("Click to select a document from the list");
     if ( d->showNew )
         text += tr(", or select <b>New Document</b> to create a new document.");
     text += tr("<br><br>Click and hold for document properties.");
     QWhatsThis::add( this, text );
 }
 
 #include "fileselector.moc"
 
diff --git a/library/fontdatabase.cpp b/library/fontdatabase.cpp
index 2b5e0d2..147134c 100644
--- a/library/fontdatabase.cpp
+++ b/library/fontdatabase.cpp
@@ -1,232 +1,230 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qpe/qpeapplication.h>
 #include "fontfactoryinterface.h"
 #include "fontdatabase.h"
 
 #include <qpe/qlibrary.h>
 
-#ifdef QWS
 #include <qfontmanager_qws.h>
-#endif
 #include <qdir.h>
 #include <qdict.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 static QString fontDir()
 {
     QString qtdir = getenv("QTDIR");
     if ( qtdir.isEmpty() ) qtdir = "/usr/local/qt-embedded";
     return qtdir+"/lib/fonts/";
 }
 
 #ifdef QT_NO_FONTDATABASE
 static QString fontFamily( const QString& key )
 {
     int u0 = key.find('_');
     int u1 = key.find('_',u0+1);
     int u2 = key.find('_',u1+1);
     QString family = key.left(u0);
     //int pointSize = key.mid(u0+1,u1-u0-1).toInt();
     //int weight = key.mid(u1+1,u2-u1-1).toInt();
     //bool italic = key.mid(u2-1,1) == "i";
     // #### ignores _t and _I fields
     return family;
 }
 #endif
 
 QValueList<FontFactory> *FontDatabase::factoryList = 0;
 
 /*!
   \class FontDatabase fontdatabase.h
   \brief The FontDatabase class provides information about available fonts.
 
   Most often you will simply want to query the database for the
   available font families().
 
   Use FontDatabase rather than QFontDatabase when you may need access
   to fonts that are not normally available. For example, if the
   freetype library and the Qtopia freetype plugin are installed,
   TrueType fonts will be available to your application. Font renderer
   plugins have greater resource requirements than system fonts so they
   should be used only when necessary. You can force the loading of
   font renderer plugins with loadRenderers().
 
   \ingroup qtopiaemb
 */
 
 /*!
   Constructs a FontDatabase object.
 */
 FontDatabase::FontDatabase()
 #ifndef QT_NO_FONTDATABASE
     : QFontDatabase()
 #endif
 {
     if ( !factoryList )
         loadRenderers();
 }
 
 /*!
   Returns a list of names of all the available font families.
 */
 QStringList FontDatabase::families() const
 {
 #ifndef QT_NO_FONTDATABASE
     return QFontDatabase::families();
 #else
     QStringList list;
     QDict<void> familyDict;
     QDiskFont *qdf;
     for ( qdf=qt_fontmanager->diskfonts.first(); qdf!=0;
             qdf=qt_fontmanager->diskfonts.next()) {
         QString familyname = qdf->name;
         if ( !familyDict.find( familyname ) ) {
             familyDict.insert( familyname, (void *)1 );
             list.append( familyname );
         }
     }
 
     QDir dir(fontDir(),"*.qpf");
     for (int i=0; i<(int)dir.count(); i++) {
         QString familyname = fontFamily(dir[i]);
         if ( !familyDict.find( familyname ) ) {
             familyDict.insert( familyname, (void *)1 );
             list.append( familyname );
         }
     }
 
     return list;
 #endif
 }
 
 #ifdef QT_NO_FONTDATABASE
 /*!
   Returns a list of standard fontsizes.
 */
 QValueList<int> FontDatabase::standardSizes()
 {
     static int s[]={ 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28,
                      36, 48, 72, 0 };
     static bool first = TRUE;
     static QValueList<int> sList;
     if ( first ) {
         first = FALSE;
         int i = 0;
         while( s[i] )
             sList.append( s[i++] );
     }
     return sList;
 }
 
 #endif
 
 /*!
   Load any font renderer plugins that are available and make the fonts
   that the plugins can read available.
 */
 void FontDatabase::loadRenderers()
 {
 #ifndef QT_NO_COMPONENT
     if ( !factoryList )
         factoryList = new QValueList<FontFactory>;
 
     QValueList<FontFactory>::Iterator mit;
     for ( mit = factoryList->begin(); mit != factoryList->end(); ++mit ) {
         qt_fontmanager->factories.setAutoDelete( false );
         qt_fontmanager->factories.removeRef( (*mit).factory );
         qt_fontmanager->factories.setAutoDelete( true );
         (*mit).interface->release();
         (*mit).library->unload();
         delete (*mit).library;
     }
     factoryList->clear();
 
     QString path = QPEApplication::qpeDir() + "/plugins/fontfactories";
     QDir dir( path, "lib*.so" );
     QStringList list = dir.entryList();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         FontFactoryInterface *iface = 0;
         QLibrary *lib = new QLibrary( path + "/" + *it );
         if ( lib->queryInterface( IID_FontFactory, (QUnknownInterface**)&iface ) == QS_OK ) {
             FontFactory factory;
             factory.library = lib;
             factory.interface = iface;
             factory.factory = factory.interface->fontFactory();
             factoryList->append( factory );
             qt_fontmanager->factories.append( factory.factory );
             readFonts( factory.factory );
         } else {
             delete lib;
         }
     }
 #endif
 }
 
 /*!
   \internal
 */
 void FontDatabase::readFonts( QFontFactory *factory )
 {
     // Load in font definition file
     QString fn = fontDir() + "fontdir";
     FILE* fontdef=fopen(fn.local8Bit(),"r");
     if(!fontdef) {
         QCString temp=fn.local8Bit();
         qWarning("Cannot find font definition file %s - is $QTDIR set correctly?",
                temp.data());
         return;
     }
     char buf[200]="";
     char name[200]="";
     char render[200]="";
     char file[200]="";
     char flags[200]="";
     char isitalic[10]="";
     fgets(buf,200,fontdef);
     while(!feof(fontdef)) {
         if ( buf[0] != '#' ) {
             int weight=50;
             int size=0;
             flags[0]=0;
             sscanf(buf,"%s %s %s %s %d %d %s",name,file,render,isitalic,&weight,&size,flags);
             QString filename;
             if ( file[0] != '/' )
                 filename = fontDir();
             filename += file;
             if ( QFile::exists(filename) ) {
                 if( factory->name() == render ) {
                     QDiskFont * qdf=new QDiskFont(factory,name,isitalic[0]=='y',
                                                   weight,size,flags,filename);
                     qt_fontmanager->diskfonts.append(qdf);
 #if QT_VERSION >= 232
                     QFontDatabase::qwsAddDiskFont( qdf );
 #endif
                 }
             }
         }
         fgets(buf,200,fontdef);
     }
     fclose(fontdef);
 }
 
diff --git a/library/fontmanager.cpp b/library/fontmanager.cpp
index 28a5212..c854133 100644
--- a/library/fontmanager.cpp
+++ b/library/fontmanager.cpp
@@ -1,103 +1,101 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
-#ifdef QWS
 #include "fontmanager.h"
 #include <qfile.h>
 #include <stdlib.h>
 #include <qgfx_qws.h>
 
 
 
 /*
     QFontInfo doesn't work in QWS at the moment,
     otherwise we would just have used that to check
     the real values
     
      For now, there are only two Unicode fonts in
      the known universe...
     
 */
 
 bool FontManager::hasUnicodeFont()
 {
     QString fontDir = getenv("QTDIR") + QString("/lib/fonts/");
 
     QString suffix;
     if ( qt_screen->isTransformed() ) {
         suffix += "_t";
         QPoint a = qt_screen->mapToDevice(QPoint(0,0),QSize(2,2));
         QPoint b = qt_screen->mapToDevice(QPoint(1,1),QSize(2,2));
         suffix += QString::number( a.x()*8+a.y()*4+(1-b.x())*2+(1-b.y()) );
     }
     suffix += ".qpf";
 
     return QFile::exists( fontDir+"cyberbit_120_50"+suffix )
         || QFile::exists( fontDir+"unifont_160_50"+suffix ) ||
         QFile::exists( fontDir+"arial_140_50" + suffix );
 }
 
 QFont FontManager::unicodeFont( Spacing sp )
 {
     QString key;
     QString fontName;
     QString fontDir = getenv("QTDIR") + QString("/lib/fonts/");
 
     int size;
     if ( sp == Proportional ) {
         fontName = "Arial";
         size=14;
         key = "arial_140_50";
     } else {
         fontName = "Unifont";
         size=16;
         key = "unifont_160_50";
     }
         
     QString suffix;
     if ( qt_screen->isTransformed() ) {
         suffix += "_t";
         QPoint a = qt_screen->mapToDevice(QPoint(0,0),QSize(2,2));
         QPoint b = qt_screen->mapToDevice(QPoint(1,1),QSize(2,2));
         suffix += QString::number( a.x()*8+a.y()*4+(1-b.x())*2+(1-b.y()) );
     }
     suffix += ".qpf";
 
     // if we cannot find it, try the other one
         
     if ( !QFile::exists(fontDir+key+suffix) ) {
         key = (sp == Fixed ) ? "arial_140_50" : "unifont_160_50";
         if ( QFile::exists(fontDir+key+suffix) ) {
             fontName = (sp == Fixed) ? "Arial" : "Unifont";
             size = (sp == Fixed) ? 14 : 16;
         } else {
             key = "cyberbit_120_50";
             if ( QFile::exists(fontDir+key+suffix) ) {
                 fontName = "Cyberbit";
                 size = 12;
             } else {
                 fontName = "Helvetica";
                 size = 14;
             }
         }
     }
     return QFont(fontName,size);
 }
-#endif
diff --git a/library/global.cpp b/library/global.cpp
index 9b908bf..d02e711 100644
--- a/library/global.cpp
+++ b/library/global.cpp
@@ -1,812 +1,806 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #define QTOPIA_INTERNAL_LANGLIST
 #include <qpe/qpedebug.h>
 #include <qpe/global.h>
 #include <qpe/qdawg.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 #include <qpe/applnk.h>
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
-#include "qpe/qcopenvelope_qws.h"
-#endif
+#include <qpe/qcopenvelope_qws.h>
 
 #include <qfile.h>
 #include <qlabel.h>
 #include <qtimer.h>
 #include <qmap.h>
 #include <qdict.h>
 #include <qdir.h>
 #include <qmessagebox.h>
 #include <qregexp.h>
 
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 
-#ifdef QWS
 #include <qwindowsystem_qws.h> // for qwsServer
-#endif
 #include <qdatetime.h>
 
 #include <qfile.h>
 
 namespace {
   // checks if the storage should be searched
   bool checkStorage(const QString &path ){ // this is a small Config replacement cause config is too limited -zecke
     QFile file(path );
     if(!file.open(IO_ReadOnly ) )
        return true;
 
     QByteArray array = file.readAll();
     QStringList list = QStringList::split('\n', QString( array ) );
     for(QStringList::Iterator it = list.begin(); it != list.end(); ++it ){
       if( (*it).startsWith("autocheck = 0" ) ){
         return false;
       }else if( (*it).startsWith("autocheck = 1" ) ){
         return true;
       }
     }
     return true;
   }
 }
 
 //#include "quickexec_p.h"
 
 class Emitter : public QObject {
     Q_OBJECT
 public:
     Emitter( QWidget* receiver, const QString& document )
     {
         connect(this, SIGNAL(setDocument(const QString&)),
             receiver, SLOT(setDocument(const QString&)));
         emit setDocument(document);
         disconnect(this, SIGNAL(setDocument(const QString&)),
                receiver, SLOT(setDocument(const QString&)));
     }
 
 signals:
     void setDocument(const QString&);
 };
 
 
 class StartingAppList : public QObject {
     Q_OBJECT
 public:
     static void add( const QString& name );
     static bool isStarting( const QString name );
 private slots:
     void handleNewChannel( const QString &);
 private:
     StartingAppList( QObject *parent=0, const char* name=0 ) ;
 
     QDict<QTime> dict;
     static StartingAppList *appl;
 };
 
 StartingAppList* StartingAppList::appl = 0;
 
 StartingAppList::StartingAppList( QObject *parent, const char* name )
     :QObject( parent, name )
 {
-#ifdef QWS
 #if QT_VERSION >= 232 && !defined(QT_NO_COP)
     connect( qwsServer, SIGNAL( newChannel(const QString&)),
              this, SLOT( handleNewChannel(const QString&)) );
     dict.setAutoDelete( TRUE );
 #endif
-#endif
 }
 
 void StartingAppList::add( const QString& name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
     if ( !appl )
         appl = new StartingAppList;
     QTime *t = new QTime;
     t->start();
     appl->dict.insert( "QPE/Application/" + name, t );
 #endif
 }
 
 bool StartingAppList::isStarting( const QString name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
     if ( appl ) {
         QTime *t  = appl->dict.find( "QPE/Application/" + name );
         if ( !t )
             return FALSE;
         if ( t->elapsed() > 10000 ) {
             // timeout in case of crash or something
             appl->dict.remove( "QPE/Application/" + name );
             return FALSE;
         }
         return TRUE;
     }
 #endif
     return FALSE;
 }
 
 void StartingAppList::handleNewChannel( const QString & name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
     dict.remove( name );
 #endif
 }
 
 static bool docDirCreated = FALSE;
 static QDawg* fixed_dawg = 0;
 static QDict<QDawg> *named_dawg = 0;
 
 static QString qpeDir()
 {
     QString dir = getenv("OPIEDIR");
     if ( dir.isEmpty() ) dir = "..";
     return dir;
 }
 
 static QString dictDir()
 {
     return qpeDir() + "/etc/dict";
 }
 
 /*!
   \class Global global.h
   \brief The Global class provides application-wide global functions.
 
   The Global functions are grouped as follows:
   \tableofcontents
 
   \section1 User Interface
 
   The statusMessage() function provides short-duration messages to the
   user. The showInputMethod() function shows the current input method,
   and hideInputMethod() hides the input method.
 
   \section1 Document related
 
   The findDocuments() function creates a set of \link doclnk.html
   DocLnk\endlink objects in a particular folder.
 
   \section1 Filesystem related
 
   Global provides an applicationFileName() function that returns the
   full path of an application-specific file.
 
   The execute() function runs an application.
 
   \section1 Word list related
 
   A list of words relevant to the current locale is maintained by the
   system. The list is held in a \link qdawg.html DAWG\endlink
   (implemented by the QDawg class). This list is used, for example, by
   the pickboard input method.
 
   The global QDawg is returned by fixedDawg(); this cannot be updated.
   An updatable copy of the global QDawg is returned by addedDawg().
   Applications may have their own word lists stored in \l{QDawg}s
   which are returned by dawg(). Use addWords() to add words to the
   updateable copy of the global QDawg or to named application
   \l{QDawg}s.
 
   \section1 Quoting
 
   The shellQuote() function quotes a string suitable for passing to a
   shell. The stringQuote() function backslash escapes '\' and '"'
   characters.
 
   \section1 Hardware
 
   The writeHWClock() function sets the hardware clock to the system
   clock's date and time.
 
   \ingroup qtopiaemb
 */
 
 /*!
   \internal
 */
 Global::Global()
 {
 }
 
 /*!
   Returns the unchangeable QDawg that contains general
   words for the current locale.
 
   \sa addedDawg()
 */
 const QDawg& Global::fixedDawg()
 {
     if ( !fixed_dawg ) {
         if ( !docDirCreated )
             createDocDir();
 
         fixed_dawg = new QDawg;
         QString dawgfilename = dictDir() + "/dawg";
         QString words_lang;
         QStringList langs = Global::languageList();
         for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
             QString lang = *it;
             words_lang = dictDir() + "/words." + lang;
             QString dawgfilename_lang = dawgfilename + "." + lang;
             if ( QFile::exists(dawgfilename_lang) ||
                  QFile::exists(words_lang) ) {
                 dawgfilename = dawgfilename_lang;
                 break;
             }
         }
         QFile dawgfile(dawgfilename);
 
         if ( !dawgfile.exists() ) {
             QString fn = dictDir() + "/words";
             if ( QFile::exists(words_lang) )
                 fn = words_lang;
             QFile in(fn);
             if ( in.open(IO_ReadOnly) ) {
                 fixed_dawg->createFromWords(&in);
                 dawgfile.open(IO_WriteOnly);
                 fixed_dawg->write(&dawgfile);
                 dawgfile.close();
             }
         } else {
             fixed_dawg->readFile(dawgfilename);
         }
     }
 
     return *fixed_dawg;
 }
 
 /*!
   Returns the changeable QDawg that contains general
   words for the current locale.
 
   \sa fixedDawg()
 */
 const QDawg& Global::addedDawg()
 {
     return dawg("local");
 }
 
 /*!
   Returns the QDawg with the given \a name.
   This is an application-specific word list.
 
   \a name should not contain "/".
 */
 const QDawg& Global::dawg(const QString& name)
 {
     createDocDir();
     if ( !named_dawg )
         named_dawg = new QDict<QDawg>;
     QDawg* r = named_dawg->find(name);
     if ( !r ) {
         r = new QDawg;
         named_dawg->insert(name,r);
         QString dawgfilename = applicationFileName("Dictionary", name ) + ".dawg";
         QFile dawgfile(dawgfilename);
         if ( dawgfile.open(IO_ReadOnly) )
             r->readFile(dawgfilename);
     }
     return *r;
 }
 
 /*!
   \overload
   Adds \a wordlist to the addedDawg().
 
   Note that the addition of words persists between program executions
   (they are saved in the dictionary files), so you should confirm the
   words with the user before adding them.
 */
 void Global::addWords(const QStringList& wordlist)
 {
     addWords("local",wordlist);
 }
 
 /*!
   \overload
   Adds \a wordlist to the addedDawg().
 
   Note that the addition of words persists between program executions
   (they are saved in the dictionary files), so you should confirm the
   words with the user before adding them.
 */
 void Global::addWords(const QString& dictname, const QStringList& wordlist)
 {
     QDawg& d = (QDawg&)dawg(dictname);
     QStringList all = d.allWords() + wordlist;
     d.createFromWords(all);
 
     QString dawgfilename = applicationFileName("Dictionary", dictname) + ".dawg";
     QFile dawgfile(dawgfilename);
     if ( dawgfile.open(IO_WriteOnly) ) {
         d.write(&dawgfile);
         dawgfile.close();
     }
 
     // #### Re-read the dawg here if we use mmap().
 
     // #### Signal other processes to re-read.
 }
 
 
 /*!
   Returns the full path for the application called \a appname, with the
   given \a filename. Returns QString::null if there was a problem creating
   the directory tree for \a appname.
   If \a filename contains "/", it is the caller's responsibility to
   ensure that those directories exist.
 */
 QString Global::applicationFileName(const QString& appname, const QString& filename)
 {
     QDir d;
     QString r = getenv("HOME");
     r += "/Applications/";
     if ( !QFile::exists( r ) )
         if ( d.mkdir(r) == false )
             return QString::null;
     r += appname;
     if ( !QFile::exists( r ) )
         if ( d.mkdir(r) == false )
             return QString::null;
     r += "/"; r += filename;
     return r;
 }
 
 /*!
   \internal
 */
 void Global::createDocDir()
 {
     if ( !docDirCreated ) {
         docDirCreated = TRUE;
         mkdir( QPEApplication::documentDir().latin1(), 0755 );
     }
 }
 
 
 /*!
   Displays a status \a message to the user. This usually appears
   in the taskbar for a short amount of time, then disappears.
 */
 void Global::statusMessage(const QString& message)
 {
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if!defined(QT_NO_COP)
     QCopEnvelope e( "QPE/TaskBar", "message(QString)" );
     e << message;
 #endif
 }
 
 /*!
   \internal
 */
 void Global::applyStyle()
 {
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QCopChannel::send( "QPE/System", "applyStyle()" );
 #else
     ((QPEApplication *)qApp)->applyStyle(); // apply without needing QCop for floppy version
 #endif
 }
 
 /*!
   \internal
 */
 QWidget *Global::shutdown( bool )
 {
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QCopChannel::send( "QPE/System", "shutdown()" );
 #endif
     return 0;
 }
 
 /*!
   \internal
 */
 QWidget *Global::restart( bool )
 {
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QCopChannel::send( "QPE/System", "restart()" );
 #endif
     return 0;
 }
 
 /*!
   Explicitly show the current input method.
 
   Input methods are indicated in the taskbar by a small icon. If the
   input method is activated (shown) then it takes up some proportion
   of the bottom of the screen, to allow the user to interact (input
   characters) with it.
 
   \sa hideInputMethod()
 */
 void Global::showInputMethod()
 {
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QCopChannel::send( "QPE/TaskBar", "showInputMethod()" );
 #endif
 }
 
 /*!
   Explicitly hide the current input method.
 
   The current input method is still indicated in the taskbar, but no
   longer takes up screen space, and can no longer be interacted with.
 
   \sa showInputMethod()
 */
 void Global::hideInputMethod()
 {
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QCopChannel::send( "QPE/TaskBar", "hideInputMethod()" );
 #endif
 }
 
 
 /*!
   \internal
 */
 bool Global::isBuiltinCommand( const QString &name )
 {
     if(!builtin)
         return FALSE; // yes, it can happen
     for (int i = 0; builtin[i].file; i++) {
         if ( builtin[i].file == name ) {
             return TRUE;
         }
     }
     return FALSE;
 }
 
 Global::Command* Global::builtin=0;
 QGuardedPtr<QWidget> *Global::running=0;
 
 /*!
   \class Global::Command
   \brief The Global::Command class is internal.
   \internal
 */
 
 /*!
   \internal
 */
 void Global::setBuiltinCommands( Command* list )
 {
     if ( running )
         delete [] running;
 
     builtin = list;
     int count = 0;
     if (!builtin)
         return;
     while ( builtin[count].file )
         count++;
 
     running = new QGuardedPtr<QWidget> [ count ];
 }
 
 /*!
   \internal
 */
 void Global::setDocument( QWidget* receiver, const QString& document )
 {
     Emitter emitter(receiver,document);
 }
 
 /*!
   \internal
 */
 bool Global::terminateBuiltin( const QString& n )
 {
     if (!builtin)
         return FALSE;
     for (int i = 0; builtin[i].file; i++) {
         if ( builtin[i].file == n ) {
             delete running[i];
             return TRUE;
         }
     }
     return FALSE;
 }
 
 /*!
   \internal
 */
 void Global::terminate( const AppLnk* app )
 {
     //if ( terminateBuiltin(app->exec()) ) return; // maybe? haven't tried this
 
 #ifndef QT_NO_COP
     QCString channel = "QPE/Application/" + app->exec().utf8();
     if ( QCopChannel::isRegistered(channel) ) {
         QCopEnvelope e(channel, "quit()");
     }
 #endif
 }
 
 /*!
   Low-level function to run command \a c.
 
   \warning Do not use this function. Use execute instead.
 
   \sa execute()
 */
 void Global::invoke(const QString &c)
 {
     // Convert the command line in to a list of arguments
     QStringList list = QStringList::split(QRegExp("  *"),c);
 
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QString ap=list[0];
     // see if the application is already running
     // XXX should lock file /tmp/qcop-msg-ap
     if ( QCopChannel::isRegistered( ("QPE/Application/" + ap).latin1() ) ) {
         // If the channel is already register, the app is already running, so show it.
         { QCopEnvelope env( ("QPE/Application/" + ap).latin1(), "raise()" ); }
                 
         QCopEnvelope e("QPE/System", "notBusy(QString)" );
         e << ap;
         return;
     }
     // XXX should unlock file /tmp/qcop-msg-ap
     //see if it is being started
     if ( StartingAppList::isStarting( ap ) ) {
         QCopEnvelope e("QPE/System", "notBusy(QString)" );
         e << ap;
         return;
     }
 
 #endif
 
 #ifdef QT_NO_QWS_MULTIPROCESS
     QMessageBox::warning( 0, "Error", "Could not find the application " + c, "Ok", 0, 0, 0, 1 );
 #else
 
     QStrList slist;
     unsigned int j;
     for ( j = 0; j < list.count(); j++ )
         slist.append( list[j].utf8() );
 
     const char **args = new (const char *)[slist.count() + 1];
     for ( j = 0; j < slist.count(); j++ )
         args[j] = slist.at(j);
     args[j] = NULL;
 
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     // an attempt to show a wait...
     // more logic should be used, but this will be fine for the moment...
     QCopEnvelope ( "QPE/System", "busy()" );
 #endif
 
 #ifdef HAVE_QUICKEXEC
     QString libexe = qpeDir()+"/binlib/lib"+args[0] + ".so";
     qDebug("libfile = %s", libexe.latin1() );
     if ( QFile::exists( libexe ) ) {
         qDebug("calling quickexec %s", libexe.latin1() );
         quickexecv( libexe.utf8().data(), (const char **)args );
     } else
 #endif
     {
         if ( !::vfork() ) {
             for ( int fd = 3; fd < 100; fd++ )
                 ::close( fd );
             ::setpgid( ::getpid(), ::getppid() );
             // Try bindir first, so that foo/bar works too
             ::execv( qpeDir()+"/bin/"+args[0], (char * const *)args );
             ::execvp( args[0], (char * const *)args );
             _exit( -1 );
         }
     }
     StartingAppList::add( list[0] );
 #endif //QT_NO_QWS_MULTIPROCESS
 }
 
 
 /*!
   Executes the application identfied by \a c, passing \a
   document if it isn't null.
 
   Note that a better approach might be to send a QCop message to the
   application's QPE/Application/\e{appname} channel.
 */
 void Global::execute( const QString &c, const QString& document )
 {
     if ( qApp->type() != QApplication::GuiServer ) {
         // ask the server to do the work
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
         if ( document.isNull() ) {
             QCopEnvelope e( "QPE/System", "execute(QString)" );
             e << c;
         } else {
             QCopEnvelope e( "QPE/System", "execute(QString,QString)" );
             e << c << document;
         }
 #endif
         return;
     }
 
     // Attempt to execute the app using a builtin class for the app first
     // else try and find it in the bin directory
     if (builtin) {
         for (int i = 0; builtin[i].file; i++) {
             if ( builtin[i].file == c ) {
                 if ( running[i] ) {
                     if ( !document.isNull() && builtin[i].documentary )
                         setDocument(running[i], document);
                     running[i]->raise();
                     running[i]->show();
                     running[i]->setActiveWindow();
                 } else {
                     running[i] = builtin[i].func( builtin[i].maximized );
                 }
 #ifndef QT_NO_COP
                 QCopEnvelope e("QPE/System", "notBusy(QString)" );
                 e << c; // that was quick ;-)
 #endif
                 return;
             }
         }
     }
 
     //Global::invoke(c, document);
 
     // Convert the command line in to a list of arguments
     QStringList list = QStringList::split(QRegExp("  *"),c);
 
-#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+#if !defined(QT_NO_COP)
     QString ap=list[0];
 
     qDebug("executing %s", ap.latin1() );
 
     /* if need be, sending a qcop message will result in an invoke, see
        preceeding function */
     invoke( ap );
     //{ QCopEnvelope env( ("QPE/Application/" + ap).latin1(), "raise()" ); }
     if ( !document.isEmpty() ) {
         QCopEnvelope env( ("QPE/Application/" + ap).latin1(), "setDocument(QString)" );
         env << document;
     }
 #endif
 }
 
 /*!
   Returns the string \a s with the characters '\', '"', and '$' quoted
   by a preceeding '\'.
 
   \sa stringQuote()
 */
 QString Global::shellQuote(const QString& s)
 {
     QString r="\"";
     for (int i=0; i<(int)s.length(); i++) {
         char c = s[i].latin1();
         switch (c) {
             case '\\': case '"': case '$':
                 r+="\\";
         }
         r += s[i];
     }
     r += "\"";
     return r;
 }
 
 /*!
   Returns the string \a s with the characters '\' and '"' quoted by a
   preceeding '\'.
 
   \sa shellQuote()
 */
 QString Global::stringQuote(const QString& s)
 {
     QString r="\"";
     for (int i=0; i<(int)s.length(); i++) {
         char c = s[i].latin1();
         switch (c) {
             case '\\': case '"':
                 r+="\\";
         }
         r += s[i];
     }
     r += "\"";
     return r;
 }
 
 /*!
   Finds all documents on the system's document directories which
   match the filter \a mimefilter, and appends the resulting DocLnk
   objects to \a folder.
 */
 void Global::findDocuments(DocLnkSet* folder, const QString &mimefilter)
 {
     QString homedocs = QString(getenv("HOME")) + "/Documents";
     DocLnkSet d(homedocs,mimefilter);
     folder->appendFrom(d);
     /** let's do intellegint way of searching these files
      *  a) the user don't want to check mediums global
      *  b) the user wants to check but use the global options for it
      *  c) the user wants to check it but not this medium
      *  d) the user wants to check and this medium as well
      *
      *  In all cases we need to apply a different mimefilter to
      *  the medium.
      *  a) mimefilter.isEmpty() we need to apply the responding filter
      *     either the global or the one on the medium
      *
      *  b) mimefilter is set to an application we need to find out if the
      *     mimetypes are included in the mime mask of the medium
      */
     StorageInfo storage;
     const QList<FileSystem> &fs = storage.fileSystems();
     QListIterator<FileSystem> it ( fs );
     for ( ; it.current(); ++it ) {
       if ( (*it)->isRemovable() ) { // let's find out  if we should search on it
         // this is a candidate look at the cf and see if we should search on it
         QString path = (*it)->path();
         if( !checkStorage((*it)->path() + "/.opiestorage.cf" ) )
           continue;
         DocLnkSet ide( path, mimefilter );
         folder->appendFrom(ide);
       } else if ( (*it)->disk() == "/dev/mtdblock6" || (*it)->disk() == "tmpfs" ) {
         QString path = (*it)->path() + "/Documents";
         DocLnkSet ide( path, mimefilter );
         folder->appendFrom(ide);
       }
     }
 }
 
 QStringList Global::languageList()
 {
     QString lang = getenv("LANG");
     QStringList langs;
     langs.append(lang);
     int i  = lang.find(".");
     if ( i > 0 )
         lang = lang.left( i );
     i = lang.find( "_" );
     if ( i > 0 )
         langs.append(lang.left(i));
     return langs;
 }
 
 QStringList Global::helpPath()
 {
     QStringList path;
     QStringList langs = Global::languageList();
     for (QStringList::ConstIterator it = langs.fromLast(); it!=langs.end(); --it) {
         QString lang = *it;
         if ( !lang.isEmpty() )
             path += QPEApplication::qpeDir() + "/help/" + lang + "/html";
     }
     path += QPEApplication::qpeDir() + "/pics";
     path += QPEApplication::qpeDir() + "/help/html";
     path += QPEApplication::qpeDir() + "/docs";
 
 
     return path;
 }
 
 
 #include "global.moc"
diff --git a/library/ir.cpp b/library/ir.cpp
index a7cf7b1..b5b726d 100644
--- a/library/ir.cpp
+++ b/library/ir.cpp
@@ -1,120 +1,118 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "ir.h"
 
 #include <qstring.h>
-#ifdef QWS
 #include "qcopenvelope_qws.h"
 #include <qcopchannel_qws.h>
-#endif
 #include "applnk.h"
 
 /*!
   \class Ir ir.h
   \brief The Ir class implements basic support for sending objects over an
   infrared communication link.
 
   Both \link doclnk.html DocLnk\endlink objects and files can be
   sent to another device via the infrared link using the send()
   function. When the send has completed the done() signal is
   emitted.
 
   The supported() function returns whether the device supports
   infrared communication or not.
 
   \ingroup qtopiaemb
 */
 
 /*!
   Constructs an Ir object. The \a parent and \a name classes are the
   standard QObject parameters.
 */
 Ir::Ir( QObject *parent, const char *name )
     : QObject( parent, name )
 {
 #ifndef QT_NO_COP
     ch = new QCopChannel( "QPE/Obex" );
     connect( ch, SIGNAL(received(const QCString &, const QByteArray &)),
              this, SLOT(obexMessage( const QCString &, const QByteArray &)) );
 #endif
 }
 
 /*!
   Returns TRUE if the system supports infrared communication;
   otherwise returns FALSE.
 */
 bool Ir::supported()
 {
 #ifndef QT_NO_COP
     return QCopChannel::isRegistered( "QPE/Obex" );
 #endif
 }
 
 /*!
   Sends the object in file \a fn over the infrared link. The \a
   description is used in the text shown to the user while sending
   is in progress. The optional \a mimetype parameter specifies the
   mimetype of the object. If this parameter is not set, it is
   determined by the the filename's suffix.
 
   \sa done()
 */
 void Ir::send( const QString &fn, const QString &description, const QString &mimetype)
 {
     if ( !filename.isEmpty() ) return;
     filename = fn;
 #ifndef QT_NO_COP
     QCopEnvelope e("QPE/Obex", "send(QString,QString,QString)");
     e << description << filename << mimetype;
 #endif
 }
 
 /*!
   \overload
 
   Uses the DocLnk::file() and DocLnk::type() of \a doc.
 
   \sa done()
 */
 void Ir::send( const DocLnk &doc, const QString &description )
 {
     send( doc.file(), description, doc.type() );
 }
 
 /*!
   \fn Ir::done( Ir *ir );
 
   This signal is emitted by \a ir, when the send comand has been processed.
 */
 
 /*!\internal
  */
 void Ir::obexMessage( const QCString &msg, const QByteArray &data)
 {
     if ( msg == "done(QString)" ) {
         QString fn;
         QDataStream stream( data, IO_ReadOnly );
         stream >> fn;
         if ( fn == filename )
             emit done( this );
     }
 }
 
diff --git a/library/lnkproperties.cpp b/library/lnkproperties.cpp
index 0b50bae..50cf5af 100644
--- a/library/lnkproperties.cpp
+++ b/library/lnkproperties.cpp
@@ -1,342 +1,340 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 // WARNING: Do *NOT* define this yourself. The SL5xxx from SHARP does NOT
 //      have this class.
 #define QTOPIA_INTERNAL_FSLP
 #include "lnkproperties.h"
 #include "lnkproperties.h"
 #include "lnkpropertiesbase_p.h"
 #include "ir.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/applnk.h>
 #include <qpe/global.h>
 #include <qpe/categorywidget.h>
-#ifdef QWS
 #include <qpe/qcopenvelope_qws.h>
-#endif
 #include <qpe/filemanager.h>
 #include <qpe/config.h>
 #include <qpe/storage.h>
 #include <qpe/qpemessagebox.h>
 #include <qpe/mimetype.h>
 
 #include <qlineedit.h>
 #include <qtoolbutton.h>
 #include <qpushbutton.h>
 #include <qgroupbox.h>
 #include <qcheckbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qfile.h>
 #include <qfileinfo.h>
 #include <qmessagebox.h>
 #include <qsize.h>
 #include <qcombobox.h>
 #include <qregexp.h>
 #include <qbuttongroup.h>
 
 #include <stdlib.h>
 
 LnkProperties::LnkProperties( AppLnk* l, QWidget* parent )
     : QDialog( parent, 0, TRUE ), lnk(l), fileSize( 0 )
 {
     setCaption( tr("Properties") );
 
     QVBoxLayout *vbox = new QVBoxLayout( this );
     d = new LnkPropertiesBase( this );
     vbox->add( d );
 
     d->docname->setText(l->name());
     QString inf;
     if ( l->type().isEmpty() ) {
         d->type->hide();
         d->typeLabel->hide();
     } else {
         d->type->setText( l->type() );
     }
 
     if ( l->comment().isEmpty() ) {
         d->comment->hide();
         d->commentLabel->hide();
     } else {
         d->comment->setText( l->comment() );
     }
 
     connect(d->beam,SIGNAL(clicked()),this,SLOT(beamLnk()));
     if ( lnk->type().contains('/') ) { // A document? (#### better predicate needed)
         connect(d->unlink,SIGNAL(clicked()),this,SLOT(unlinkLnk()));
         connect(d->duplicate,SIGNAL(clicked()),this,SLOT(duplicateLnk()));
 
         d->docname->setReadOnly( FALSE );
         d->preload->hide();
         d->rotate->hide();
         d->rotateButtons->hide();
         d->labelspacer->hide();
 
         // ### THIS MUST GO, FIX WIERD BUG in QLAYOUT
         d->categoryEdit->kludge();
 
         d->categoryEdit->setCategories( lnk->categories(),
                                         "Document View",
                                         tr("Document View") );
         setupLocations();
     } else {
         d->unlink->hide();
         d->duplicate->hide();
         d->beam->hide();
         d->hline->hide();
          d->locationLabel->hide();
         d->locationCombo->hide();
 
         // Can't edit categories, since the app .desktop files are global,
         // possibly read-only.
          d->categoryEdit->hide();
 
         d->docname->setReadOnly( TRUE );
 
         if ( l->property("CanFastload") == "0" )
             d->preload->hide();
         if ( !l->property("Rotation"). isEmpty ()) {
             d->rotate->setChecked ( true );
             d->rotateButtons->setButton((l->rotation().toInt()%360)/90);
         }
         else {
             d->rotateButtons->setEnabled(false);
         }
 
         Config cfg("Launcher");
         cfg.setGroup("Preload");
         QStringList apps = cfg.readListEntry("Apps",',');
         d->preload->setChecked( apps.contains(l->exec()) );
         if ( Global::isBuiltinCommand(lnk->exec()) )
             d->preload->hide(); // builtins are always fast
 
         currentLocation = 0; // apps not movable (yet)
     }
 }
 
 LnkProperties::~LnkProperties()
 {
 }
 
 void LnkProperties::unlinkLnk()
 {
     if ( QPEMessageBox::confirmDelete( this, tr("Delete"), lnk->name() ) ) {
         lnk->removeFiles();
         if ( QFile::exists(lnk->file()) ) {
             QMessageBox::warning( this, tr("Delete"), tr("File deletion failed.") );
         } else {
             reject();
         }
     }
 }
 
 void LnkProperties::setupLocations()
 {
     QFileInfo fi( lnk->file() );
     fileSize = fi.size();
     StorageInfo storage;
     const QList<FileSystem> &fs = storage.fileSystems();
     QListIterator<FileSystem> it ( fs );
     QString s;
     QString homeDir = getenv("HOME");
     QString hardDiskHome;
     QString hardDiskPath;
     int index = 0;
     currentLocation = -1;
     for ( ; it.current(); ++it ) {
         // we add 10k to the file size so we are sure we can also save the desktop file
         if ( (ulong)(*it)->availBlocks() * (ulong)(*it)->blockSize() > (ulong)fileSize + 10000 ) {
             if ( (*it)->isRemovable() ||
                  (*it)->disk() == "/dev/mtdblock1" ||
                  (*it)->disk() == "/dev/mtdblock/1" ||
                  (*it)->disk().left(13) == "/dev/mtdblock" ||
                  (*it)->disk() == "/dev/mtdblock6" || 
                  (*it)->disk() == "tmpfs" ) {
                 d->locationCombo->insertItem( (*it)->name(), index );
                 locations.append( ( ((*it)->isRemovable() || 
                                     (*it)->disk() == "/dev/mtdblock6" ||
                                     (*it)->disk() == "tmpfs" )
                                     ? (*it)->path() : homeDir) );
                 if ( lnk->file().contains( (*it)->path() ) ) {
                      d->locationCombo->setCurrentItem( index );
                      currentLocation = index;
                 }
                 index++;
             } else if ( (*it)->name().contains( tr("Hard Disk") ) &&
                         homeDir.contains( (*it)->path() ) &&
                         (*it)->path().length() > hardDiskHome.length() ) {
                 hardDiskHome = (*it)->name();
                 hardDiskPath = (*it)->path();
             }
         }
     }
     if ( !hardDiskHome.isEmpty() ) {
         d->locationCombo->insertItem( hardDiskHome );
         locations.append( hardDiskPath );
         if ( currentLocation == -1 ) { // assume it's the hard disk
             d->locationCombo->setCurrentItem( index );
             currentLocation = index;
         }
     }
 }
 
 void LnkProperties::duplicateLnk()
 {
     // The duplicate takes the new properties.
     DocLnk newdoc( *((DocLnk *)lnk) );
     if ( d->docname->text() == lnk->name() )
         newdoc.setName(tr("Copy of ")+d->docname->text());
     else
         newdoc.setName(d->docname->text());
 
     if ( !copyFile( newdoc ) ) {
         QMessageBox::warning( this, tr("Duplicate"), tr("File copy failed.") );
         return;
     }
     reject();
 }
 
 bool LnkProperties::moveLnk()
 {
     DocLnk newdoc( *((DocLnk *)lnk) );
     newdoc.setName(d->docname->text());
 
     if ( !copyFile( newdoc ) ) {
         QMessageBox::warning( this, tr("Details"), tr("Moving Document failed.") );
         return FALSE;
     }
     // remove old lnk
     lnk->removeFiles();
 
     return TRUE;
 }
 
 void LnkProperties::beamLnk()
 {
     Ir ir;
     DocLnk doc( *((DocLnk *)lnk) );
     doc.setName(d->docname->text());
     reject();
     ir.send( doc, doc.comment() );
 }
 
 bool LnkProperties::copyFile( DocLnk &newdoc )
 {
     const char *linkExtn = ".desktop";
     QString fileExtn;
     int extnPos = lnk->file().findRev( '.' );
     if ( extnPos > 0 )
         fileExtn = lnk->file().mid( extnPos );
 
     QString safename = newdoc.name();
     safename.replace(QRegExp("/"),"_");
 
      QString fn = locations[ d->locationCombo->currentItem() ]
                   + "/Documents/" + newdoc.type() + "/" + safename;
     if ( QFile::exists(fn + fileExtn) || QFile::exists(fn + linkExtn) ) {
         int n=1;
         QString nn = fn + "_" + QString::number(n);
         while ( QFile::exists(nn+fileExtn) || QFile::exists(nn+linkExtn) ) {
             n++;
             nn = fn + "_" + QString::number(n);
         }
         fn = nn;
     }
     newdoc.setFile( fn + fileExtn );
     newdoc.setLinkFile( fn + linkExtn );
 
     // Copy file
     FileManager fm;
     if ( !fm.copyFile( *lnk, newdoc ) )
         return FALSE;
     return TRUE;
 }
 
 void LnkProperties::done(int ok)
 {
     if ( ok ) {
         bool changed=FALSE;
         bool reloadMime=FALSE;
         
         if ( lnk->name() != d->docname->text() ) {
             lnk->setName(d->docname->text());
             changed=TRUE;
         }
         if ( d->categoryEdit->isVisible() ) {
             QArray<int> tmp = d->categoryEdit->newCategories();
             if ( lnk->categories() != tmp ) {
                 lnk->setCategories( tmp );
                 changed = TRUE;
             }
         }
         if ( !d->rotate->isHidden()) {
             QString newrot;
         
             if ( d->rotate->isChecked() ) {
                 int rot=0;
                 for(; rot<4; rot++) {
                     if (d->rotateButtons->find(rot)->isOn())
                         break;
                 }
                 newrot = QString::number((rot*90)%360);
             }
             if ( newrot != lnk->rotation() ) {
                 lnk-> setRotation(newrot);
                 changed = TRUE;
                 reloadMime = TRUE;
             }
         }
         if ( d->preload->isHidden() && d->locationCombo->currentItem() != currentLocation ) {
             moveLnk();
         } else if ( changed ) {
             lnk->writeLink();
         }
         
         if ( !d->preload->isHidden() ) {
             Config cfg("Launcher");
             cfg.setGroup("Preload");
             QStringList apps = cfg.readListEntry("Apps",',');
             QString exe = lnk->exec();
             if ( apps.contains(exe) != d->preload->isChecked() ) {
                 if ( d->preload->isChecked() ) {
                     apps.append(exe);
 #ifndef QT_NO_COP
                     QCopEnvelope e("QPE/Application/"+exe.local8Bit(),
                                    "enablePreload()");
 #endif
                 } else {
                     apps.remove(exe);
 #ifndef QT_NO_COP
                     QCopEnvelope e("QPE/Application/"+exe.local8Bit(),
                                    "quitIfInvisible()");
 #endif
                 }
                 cfg.writeEntry("Apps",apps,',');
             }
         }
         if ( reloadMime )
             MimeType::updateApplications ( );
     }
     QDialog::done( ok );
 }
 
diff --git a/library/network.cpp b/library/network.cpp
index 185b147..3568809 100644
--- a/library/network.cpp
+++ b/library/network.cpp
@@ -1,446 +1,444 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_LANGLIST
 #include "qpe/network.h"
 #include "qpe/networkinterface.h"
 #include "qpe/global.h"
 #include "qpe/config.h"
 #include "qpe/resource.h"
 #include "qpe/qpeapplication.h"
-#ifdef QWS
 #include <qpe/qcopenvelope_qws.h>
-#endif
 #include <qpe/qlibrary.h>
 
 #include <qlistbox.h>
 #include <qdir.h>
 #include <qlayout.h>
 #include <qdict.h>
 #include <qtranslator.h>
 
 #include <stdlib.h>
 
 #ifndef QT_NO_COP
 class NetworkEmitter : public QCopChannel {
     Q_OBJECT
 public:
     NetworkEmitter() : QCopChannel("QPE/Network",qApp)
     {
     }
 
     void receive(const QCString &msg, const QByteArray&)
     {
         if ( msg == "choicesChanged()" )
             emit changed();
     }
 
 signals:
     void changed();
 };
 
 /*!
   \internal
 
   Requests that the service \a choice be started. The \a password is
   the password to use if required.
 */
 void Network::start(const QString& choice, const QString& password)
 {
     QCopEnvelope e("QPE/Network", "start(QString,QString)");
     e << choice << password;
 }
 
 /*!
   \class Network network.h
   \brief The Network class provides network access functionality.
   \internal
 */
 
 // copy the proxy settings of the active config over to the Proxies.conf file
 /*!
   \internal
 */
 void Network::writeProxySettings( Config &cfg )
 {
     Config proxy( Network::settingsDir() + "/Proxies.conf", Config::File );
     proxy.setGroup("Properties");
     cfg.setGroup("Proxy");
     proxy.writeEntry("type", cfg.readEntry("type") );
     proxy.writeEntry("autoconfig", cfg.readEntry("autoconfig") );
     proxy.writeEntry("httphost", cfg.readEntry("httphost") );
     proxy.writeEntry("httpport", cfg.readEntry("httpport") );
     proxy.writeEntry("ftphost", cfg.readEntry("ftphost") );
     proxy.writeEntry("ftpport", cfg.readEntry("ftpport") );
     proxy.writeEntry("noproxies", cfg.readEntry("noproxies") );
     cfg.setGroup("Properties");
 }
 
 
 
 /*!
   \internal
 
   Stops the current network service.
 */
 void Network::stop()
 {
     QCopEnvelope e("QPE/Network", "stop()");
 }
 
 static NetworkEmitter *emitter = 0;
 
 /*!
   \internal
 */
 void Network::connectChoiceChange(QObject* receiver, const char* slot)
 {
     if ( !emitter )
         emitter = new NetworkEmitter;
     QObject::connect(emitter,SIGNAL(changed()),receiver,slot);
 }
 
         #endif// QT_NO_COP
 /*!
   \internal
 */
 QString Network::settingsDir()
 {
     return Global::applicationFileName("Network", "modules");
 }
 
 #ifndef QT_NO_COP
 /*!
   \internal
 */
 QStringList Network::choices(QListBox* lb, const QString& dir)
 {
     QStringList list;
 
     if ( lb )
         lb->clear();
 
     QString adir = dir.isEmpty() ? settingsDir() : dir;
     QDir settingsdir(adir);
     settingsdir.mkdir(adir);
 
     QStringList files = settingsdir.entryList("*.conf");
     for (QStringList::ConstIterator it=files.begin(); it!=files.end(); ++it ) {
         QString filename = settingsdir.filePath(*it);
         Config cfg(filename, Config::File);
         cfg.setGroup("Info");
         if ( lb )
             lb->insertItem(Resource::loadPixmap("Network/" + cfg.readEntry("Type")),
                 cfg.readEntry("Name"));
         list.append(filename);
     }
 
     return list;
 }
 
 class NetworkServer : public QCopChannel {
     Q_OBJECT
 public:
     NetworkServer(QObject* parent) : QCopChannel("QPE/Network",parent), wait(0)
     {
         up = FALSE;
         examineNetworks( TRUE );
         QCopChannel* card = new QCopChannel("QPE/Card",parent);
         connect(card,SIGNAL(received(const QCString &, const QByteArray&)),
             this,SLOT(cardMessage(const QCString &, const QByteArray&)));
     }
 
     ~NetworkServer()
     {
         stop();
     }
 
     bool networkOnline() const
     {
         return up;
     }
 
 private:
     void receive(const QCString &msg, const QByteArray& data)
     {
         if ( msg == "start(QString,QString)" ) {
             QDataStream stream(data,IO_ReadOnly);
             QString file,password;
             stream >> file >> password;
             if ( file.isEmpty() ) {
                 QStringList l = Network::choices();
                 for (QStringList::ConstIterator i=l.begin(); i!=l.end(); ++i) {
                     Config cfg(*i,Config::File);
                     cfg.setGroup("Info");
                     QString type = cfg.readEntry("Type");
                     NetworkInterface* plugin = Network::loadPlugin(type);
                     cfg.setGroup("Properties");
                     if ( plugin && plugin->isAvailable(cfg) ) {
                         file = *i;
                         break;
                     }
                 }
                 if ( file.isEmpty() ) {
                     QCopEnvelope("QPE/Network", "failed()");
                     return;
                 }
             }
             start(file,password);
         } else if ( msg == "stop()" ) {
             stop();
         } else if ( msg == "choicesChanged()" ) {
             examineNetworks();
         }
     }
 
 private slots:
     void cardMessage(const QCString &msg, const QByteArray&)
     {
         if ( msg == "stabChanged()" )
             examineNetworks();
     }
 
 private:
     void examineNetworks( bool firstStart = FALSE )
     {
         QStringList l = Network::choices();
         bool wasup = up; up=FALSE;
         QStringList pavailable = available;
         available.clear();
         for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
             Config cfg(*it,Config::File);
             cfg.setGroup("Info");
             QString type = cfg.readEntry("Type");
             NetworkInterface* plugin = Network::loadPlugin(type);
             cfg.setGroup("Properties");
             if ( plugin ) {
                 if ( plugin->isActive(cfg) ) {
                     up = TRUE;
                     if ( firstStart )
                         plugin->start( cfg );
                 }
                 if ( plugin->isAvailable(cfg) )
                     available.append(*it);
             }
         }
 
         // Try to work around unreproducible bug whereby
         // the netmon applet shows wrong state.
         bool reannounce = wait<0;
 
         if ( available != pavailable || reannounce ) {
             QCopEnvelope e("QPE/Network", "available(QStringList)");
             e << available;
         }
         if ( up != wasup || reannounce ) {
             QCopEnvelope("QPE/Network", up ? "up()" : "down()");
         }
     }
 
     void start( const QString& file, const QString& password )
     {
         if ( !current.isEmpty() )
             stop();
         current = QString::null;
         Config cfg(file, Config::File);
         cfg.setGroup("Info");
         QString type = cfg.readEntry("Type");
         NetworkInterface* plugin = Network::loadPlugin(type);
         bool started = FALSE;
         if ( plugin ) {
             cfg.setGroup("Properties");
             if ( plugin->start(cfg,password) ) {
                 Network::writeProxySettings( cfg );
                 current = file;
                 wait=0;
                 startTimer(400);
                 started = TRUE;
             }
         }
         if ( !started ) {
             QCopEnvelope("QPE/Network", "failed()");
         }
     }
 
     void stop()
     {
         bool stopped = FALSE;
         if ( !current.isEmpty() ) {
             Config cfg(current, Config::File);
             cfg.setGroup("Info");
             QString type = cfg.readEntry("Type");
             NetworkInterface* plugin = Network::loadPlugin(type);
             if ( plugin ) {
                 cfg.setGroup("Properties");
                 if ( plugin->stop(cfg) ) {
                     current = QString::null;
                     wait=0;
                     startTimer(400);
                     stopped = TRUE;
                 }
             }
         }
         if ( !stopped ) {
             QCopEnvelope("QPE/Network", "failed()");
         }
     }
 
     void timerEvent(QTimerEvent*)
     {
         examineNetworks();
         if ( wait >= 0 ) {
             if ( up == !current.isNull() ) {
                 // done
                 killTimers();
                 if ( up ) {
                     startTimer(3000); // monitor link
                     wait = -1;
                 }
             } else {
                 wait++;
                 if ( wait == 600 ) {
                     killTimers(); // forget about it after 240 s
                     QCopEnvelope("QPE/Network", "failed()");
                     up = !current.isNull();
                 }
             }
         } else if ( !up ) {
             killTimers();
         }
     }
 
 private:
     QStringList available;
     QString current;
     bool up;
     int wait;
 };
 
 static NetworkServer* ns=0;
 
 /*!
   \internal
 */
 QString Network::serviceName(const QString& service)
 {
     Config cfg(service, Config::File);
     cfg.setGroup("Info");
     return cfg.readEntry("Name");
 }
 
 /*!
   \internal
 */
 QString Network::serviceType(const QString& service)
 {
     Config cfg(service, Config::File);
     cfg.setGroup("Info");
     return cfg.readEntry("Type");
 }
 
 /*!
   \internal
 */
 bool Network::serviceNeedsPassword(const QString& service)
 {
     Config cfg(service,Config::File);
     cfg.setGroup("Info");
     QString type = cfg.readEntry("Type");
     NetworkInterface* plugin = Network::loadPlugin(type);
     cfg.setGroup("Properties");
     return plugin ? plugin->needPassword(cfg) : FALSE;
 }
 
 /*!
   \internal
 */
 bool Network::networkOnline()
 {
     return ns && ns->networkOnline();
 }
 
 /*!
   \internal
 */
 void Network::createServer(QObject* parent)
 {
     ns = new NetworkServer(parent);
 }
 
 /*!
   \internal
 */
 int Network::addStateWidgets(QWidget* parent)
 {
     int n=0;
     QStringList l = Network::choices();
     QVBoxLayout* vb = new QVBoxLayout(parent);
     for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
         Config cfg(*it,Config::File);
         cfg.setGroup("Info");
         QString type = cfg.readEntry("Type");
         NetworkInterface* plugin = Network::loadPlugin(type);
         cfg.setGroup("Properties");
         if ( plugin ) {
             QWidget* w;
             if ( (w=plugin->addStateWidget(parent,cfg)) ) {
                 n++;
                 vb->addWidget(w);
             }
         }
     }
     return n;
 }
 
 static QDict<NetworkInterface> *ifaces;
 
 /*!
   \internal
 */
 NetworkInterface* Network::loadPlugin(const QString& type)
 {
 #ifndef QT_NO_COMPONENT
     if ( !ifaces ) ifaces = new QDict<NetworkInterface>;
     NetworkInterface *iface = ifaces->find(type);
     if ( !iface ) {
         QString libfile = QPEApplication::qpeDir() + "/plugins/network/lib" + type + ".so";
         QLibrary lib(libfile);
         if ( !lib.queryInterface( IID_Network, (QUnknownInterface**)&iface ) == QS_OK )
             return 0;
         ifaces->insert(type,iface);
         QStringList langs = Global::languageList();
         for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
             QString lang = *it;
             QTranslator * trans = new QTranslator(qApp);
             QString tfn = QPEApplication::qpeDir()+"/i18n/"+lang+"/lib"+type+".qm";
             if ( trans->load( tfn ))
                 qApp->installTranslator( trans );
             else
                 delete trans;
         }
     }
     return iface;
 #else
     return 0;
 #endif
 }
 
 #include "network.moc"
         #endif// QT_NO_COP
diff --git a/library/networkinterface.cpp b/library/networkinterface.cpp
index 2b5c77e..0ba773a 100644
--- a/library/networkinterface.cpp
+++ b/library/networkinterface.cpp
@@ -1,106 +1,104 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "networkinterface.h"
 #include "network.h"
 #include "config.h"
 #include <stdio.h>
 
 QString NetworkInterface::device( Config& cfg ) const
 {
     return cfg.readEntry("Device");
 }
 
 bool NetworkInterface::isActive( Config& cfg ) const
 {    
     QString dev = device(cfg);
     if ( dev.isEmpty() )
         return FALSE;
     QString dev0 = dev+'0';
 
     FILE* f;
     f = fopen("/proc/net/dev", "r");
     if ( f ) {
         char line[1024];
         char devname[80];
         while ( fgets( line, 1024, f ) ) {
             if ( sscanf(line," %[^:]:", devname)==1 )
             {
                 if ( devname == dev || devname == dev0 ) {
                     fclose(f);
-#ifdef QWS
                     Network::writeProxySettings( cfg );
-#endif
                     return TRUE;
                 }
             }
         }
         fclose(f);
     }
     return FALSE;
 }
 
 QString NetworkInterface::cardType( Config& cfg ) const
 {
     return cfg.readEntry("CardType");
 }
 
 bool NetworkInterface::isAvailable( Config& cfg ) const
 {
     QString ct = cardType(cfg);
     if ( ct.isEmpty() )
         return FALSE;
 
     FILE* f = fopen("/var/run/stab", "r");
     if (!f) f = fopen("/var/state/pcmcia/stab", "r");
     if (!f) f = fopen("/var/lib/pcmcia/stab", "r");
 
     if ( f ) {
         char line[1024];
         char devtype[80];
         while ( fgets( line, 1024, f ) ) {
             if ( sscanf(line,"%*d %s %*s", devtype )==1 )
             {
                 if ( ct == devtype ) {
                     fclose(f);
                     return TRUE;
                 }
             }
         }
         fclose(f);
     }
 
     return FALSE;
 }
 
 bool NetworkInterface::start( Config& cfg, const QString& /*password*/ )
 {
     return start(cfg);
 }
 
 bool NetworkInterface::needPassword( Config& ) const
 {
     return FALSE;
 }
 
 QWidget* NetworkInterface::addStateWidget( QWidget*, Config& ) const
 {
     return 0;
 }
diff --git a/library/password.cpp b/library/password.cpp
index 41b3358..4b22b65 100644
--- a/library/password.cpp
+++ b/library/password.cpp
@@ -1,335 +1,333 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "password.h"
 #include "config.h"
 #include "global.h"
 #include "backend/contact.h"
 #include <qlabel.h>
 #include <qlineedit.h>
 #include <qtextview.h>
 #include <qstring.h>
 #include <qapplication.h>
 #include <qfile.h>
-#ifdef QWS
 #include <qwindowsystem_qws.h>
-#endif
 
 #include <qdialog.h>
 
 #include <unistd.h> //for sleep
 #include "passwordbase_p.h"
 
 class PasswordDialog : public PasswordBase
 {
     Q_OBJECT
 
 public:
     PasswordDialog( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     ~PasswordDialog();
 
     void clear();
     void setPrompt( const QString& );
 
 signals:
     void passwordEntered( const QString& );
 
 protected:
     bool eventFilter( QObject*, QEvent* );
     void keyPressEvent( QKeyEvent * );
 
 private:
     void input( QString );
     friend class Password;
     QString text;
 };
 
 
 extern "C" char *crypt(const char *key, const char *salt);
 static QString qcrypt(const QString& k, const char *salt)
 {
     return QString::fromUtf8(crypt(k.utf8(),salt));
 }
 
 /*
  *  Constructs a PasswordDialog which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  */
 PasswordDialog::PasswordDialog( QWidget* parent,  const char* name, WFlags fl )
     : PasswordBase( parent, name, fl )
 {
     QRect desk = qApp->desktop()->geometry();
 
     if ( desk.width() < 220 ) {
         QFont f( font() );
         f.setPointSize( 18 );
         setFont( f );
         f.setPointSize( 12 );
         prompt->setFont( f );
     }
     
     button_0->installEventFilter( this );
     button_1->installEventFilter( this );
     button_2->installEventFilter( this );
     button_3->installEventFilter( this );
     button_4->installEventFilter( this );
     button_5->installEventFilter( this );
     button_6->installEventFilter( this );
     button_7->installEventFilter( this );
     button_8->installEventFilter( this );
     button_9->installEventFilter( this );
     button_OK->installEventFilter( this );
     setFocus();
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 PasswordDialog::~PasswordDialog()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 
 
 /*!
   \reimp
 */
 
 bool PasswordDialog::eventFilter( QObject*o, QEvent*e )
 {
     if ( e->type() == QEvent::MouseButtonRelease ) {
         if ( o == button_OK ) {
             emit passwordEntered( text );
         } else {
             QLabel *l = (QLabel*)o;
             input(l->text());
         }
     }
     return FALSE;
 }
 
 
 /*!
   \reimp
 */
 
 void PasswordDialog::keyPressEvent( QKeyEvent * )
 {
 #if 0
     if ( e->key() == Key_Enter || e->key() == Key_Return )
         emit passwordEntered( text );
     else
         input( e->text() );
 #endif
 }
 
 
 /*!
 
 */
 
 void PasswordDialog::input( QString c )
 {
     text += c;
     display->setText( text );
 }
 
 /*!
 
 */
 
 void PasswordDialog::setPrompt( const QString& s )
 {
     prompt->setText( s );
 }
 
 void PasswordDialog::clear()
 {
     text = "";
     input("");
 }
 
 class PasswdDlg : public QDialog
 {
 public:
     PasswdDlg( QWidget *parent, const char * name, bool modal, bool fullscreen = FALSE )
         : QDialog( parent, name, modal, fullscreen ? WStyle_NoBorder | WStyle_Customize | WStyle_StaysOnTop : 0 ),
             modl(modal)
     {
         passw = new PasswordDialog( this );
 
         if ( fullscreen ) {
             QRect desk = qApp->desktop()->geometry();
             setGeometry( 0, 0, desk.width(), desk.height() );
         }
 
         connect( passw, SIGNAL(passwordEntered(const QString&)),
                  this, SLOT(accept()) );
     }
 
     void resizeEvent( QResizeEvent * )
     {
         passw->resize( size() );
     }
 
     void reset()
     {
         passw->clear();
     }
 
     void execNonModal()
     {
         if ( !modl ) {
             reset();
             showFullScreen();
             do {
                 qApp->enter_loop();
             } while (result()!=1);
         }
     }
 
     void accept()
     {
         if ( !modl )
             qApp->exit_loop();
         QDialog::accept();
     }
 
     PasswordDialog *passw;
     bool modl;
 };
 
 class OwnerDlg : public QDialog
 {
 public:
 
     OwnerDlg( QWidget *parent, const char * name, Contact c,
             bool modal, bool fullscreen = FALSE )
         : QDialog( parent, name, modal, 
                 fullscreen ? 
                 WStyle_NoBorder | WStyle_Customize | WStyle_StaysOnTop : 0 )
     {
         if ( fullscreen ) {
             QRect desk = qApp->desktop()->geometry();
             setGeometry( 0, 0, desk.width(), desk.height() );
         }
 
         // set up contents.
         QString text = "<H1>" + tr("Owner Information") + "</H1>";
         text += c.toRichText();
         tv = new QTextView(this);
         tv->setText(text);
 
         tv->viewport()->installEventFilter(this);
     }
 
     void resizeEvent( QResizeEvent * )
     {
         tv->resize( size() );
     }
    
     bool eventFilter(QObject *o, QEvent *e)
     {
         if (e->type() == QEvent::KeyPress || e->type() == QEvent::MouseButtonPress ) {
             accept();
             return TRUE;
         }
         return QWidget::eventFilter(o, e);
     }
 
     void mousePressEvent( QMouseEvent * ) { accept(); }
 
 private:
     QTextView *tv;
 };
 
 /*!
   Returns a crypted password entered by the user when prompted with \a prompt
   The returned value is QString::null if the user cancels the operation,
   or the empty string if the user enters no password (but confirms the
   dialog).
 */
 
 QString Password::getPassword( const QString& prompt )
 {
     PasswdDlg pd(0,0,TRUE);
     pd.passw->setPrompt( prompt );
 
     pd.showMaximized();
     int r = pd.exec();
 
     if ( r == QDialog::Accepted ) {
         if (pd.passw->text.isEmpty())
             return "";
         else
             return qcrypt(pd.passw->text,"a0");
     } else {
         return QString::null;
     }
 }
 
 
 /*!
   Prompt, fullscreen, for the user's passcode until they get it right.
 
   If \a at_poweron is TRUE, the dialog is only used if the user's
   preference request it at poweron; either way, the screen is always repainted
   by this function.  (this functionality may move to the caller of this function).
 */
 
 void Password::authenticate(bool at_poweron)
 {
     Config cfg("Security");
     cfg.setGroup("Passcode");
     QString passcode = cfg.readEntry("passcode");
     if ( !passcode.isEmpty()
             && (!at_poweron || cfg.readNumEntry("passcode_poweron",0)) )
     {
         // Do it as a fullscreen modal dialog
         PasswdDlg pd(0,0,TRUE,TRUE);
 
         // see if there is contact information.
         OwnerDlg *oi = 0;
         QString vfilename = Global::applicationFileName("addressbook", 
                 "businesscard.vcf");
         if (QFile::exists(vfilename)) {
             Contact c;
             c = Contact::readVCard( vfilename )[0];
 
             oi = new OwnerDlg(0, 0, c, TRUE, TRUE);
         }
 
         pd.reset();
         pd.exec();
         while (qcrypt(pd.passw->text, "a0") != passcode) {
             if (oi)
                 oi->exec();
             pd.reset();
             pd.exec();
         }
     } else if ( at_poweron ) {
         // refresh screen   #### should probably be in caller
         // Not needed (we took away the screen blacking)
         //if ( qwsServer )
             //qwsServer->refresh();
     }
 }
 
 #include "password.moc"
diff --git a/library/qpedecoration_qws.cpp b/library/qpedecoration_qws.cpp
index 214c721..9cbe92b 100644
--- a/library/qpedecoration_qws.cpp
+++ b/library/qpedecoration_qws.cpp
@@ -1,914 +1,912 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
-#ifdef QWS
 #define QTOPIA_INTERNAL_LANGLIST
 #include <qapplication.h>
 #include <qstyle.h>
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qtimer.h>
 #include <qwhatsthis.h>
 #include "qcopenvelope_qws.h"
 #include "qpedecoration_qws.h"
 #include <qdialog.h>
 #include <qdrawutil.h>
 #include <qgfx_qws.h>
 #include "qpeapplication.h"
 #include "resource.h"
 #include "global.h"
 #include "qlibrary.h"
 #include "windowdecorationinterface.h"
 #include <qfile.h>
 #include <qsignal.h>
 
 #include <stdlib.h>
 
 extern QRect qt_maxWindowRect;
 
 #define WHATSTHIS_MODE
 
 #ifndef QT_NO_QWS_QPE_WM_STYLE
 
 #ifndef QT_NO_IMAGEIO_XPM
 
 /* XPM */
 static const char * const qpe_close_xpm[] = {
 "16 16 3 1",
 "       c None",
 ".      c #FFFFFF",
 "+      c #000000",
 "                ",
 "                ",
 "      .....     ",
 "    ..+++++..   ",
 "   .+++++++++.  ",
 "   .+..+++..+.  ",
 "  .++...+...++. ",
 "  .+++.....+++. ",
 "  .++++...++++. ",
 "  .+++.....+++. ",
 "  .++...+...++. ",
 "   .+..+++..+.  ",
 "   .+++++++++.  ",
 "    ..+++++..   ",
 "      .....     ",
 "                "};
 
 /* XPM */
 static const char * const qpe_accept_xpm[] = {
 "16 16 3 1",
 "       c None",
 ".      c #FFFFFF",
 "+      c #000000",
 "                ",
 "                ",
 "      .....     ",
 "    ..+++++..   ",
 "   .+++++++++.  ",
 "   .+++++++++.  ",
 "  .+++++++..++. ",
 "  .++.+++...++. ",
 "  .+...+...+++. ",
 "  .+......++++. ",
 "  .++....+++++. ",
 "   .++..+++++.  ",
 "   .+++++++++.  ",
 "    ..+++++..   ",
 "      .....     ",
 "                "};
 
 #endif // QT_NO_IMAGEIO_XPM
 
 class HackWidget : public QWidget
 {
 public:
     bool needsOk() {
         return (getWState() & WState_Reserved1 ) ||
                  (inherits( "QDialog" ) && !inherits( "QMessageBox" ) );
     }
 };
 
 static QImage scaleButton( const QImage &img, int height )
 {
     if ( img.height() != 0 && img.height() != height ) {
         return img.smoothScale( img.width()*height/img.height(), height );
     } else {
         return img;
     }
 }
 
 class TLWidget : public QWidget
 {
 public:
     QWSManager *manager()
     {
         return topData()->qwsManager;
     }
 
     QTLWExtra *topExtra()
     {
         return topData();
     }
 
     void setWState( uint s ) { QWidget::setWState( s ); }
     void clearWState( uint s ) { QWidget::clearWState( s ); }
 };
 
 
 QPEManager::QPEManager( QPEDecoration *d, QObject *parent )
     : QObject( parent ), decoration( d ), helpState(0), inWhatsThis(FALSE)
 {
     wtTimer = new QTimer( this );
     connect( wtTimer, SIGNAL(timeout()), this, SLOT(whatsThisTimeout()) );
 }
 
 
 void QPEManager::updateActive()
 {
     QWidget *newActive = qApp->activeWindow();
     if ( newActive && (QWidget*)active == newActive )
         return;
 
     if ( active && (!newActive || ((TLWidget *)newActive)->manager()) ) {
         ((TLWidget *)(QWidget*)active)->manager()->removeEventFilter( this );
     }
 
     if ( newActive && ((TLWidget *)newActive)->manager() ) {
         active = newActive;
         ((TLWidget *)(QWidget*)active)->manager()->installEventFilter( this );
     } else if ( !newActive ) {
         active = 0;
     }
 }
 
 int QPEManager::pointInQpeRegion( QWidget *w, const QPoint &p )
 {
     QRect rect(w->geometry());
 
     if ( decoration->region( w, rect,
                 (QWSDecoration::Region)QPEDecoration::Help ).contains(p) )
         return QPEDecoration::Help;
 
     for (int i = QWSDecoration::LastRegion; i >= QWSDecoration::Title; i--) {
         if (decoration->region(w, rect, (QWSDecoration::Region)i).contains(p))
             return (QWSDecoration::Region)i;
     }
 
     return QWSDecoration::None;
 }
 
 bool QPEManager::eventFilter( QObject *o, QEvent *e )
 {
     QWSManager *mgr = (QWSManager *)o;
     QWidget *w = mgr->widget();
     switch ( e->type() ) {
         case QEvent::MouseButtonPress:
             {
                 pressTime = QTime::currentTime();
                 QPoint p = ((QMouseEvent*)e)->globalPos();
                 int inRegion = pointInQpeRegion( w, p );
 #ifdef WHATSTHIS_MODE
                 if ( !w->geometry().contains(p) && QWhatsThis::inWhatsThisMode() ) {
                     QString text;
                     switch ( inRegion ) {
                         case QWSDecoration::Close:
                             if ( ((HackWidget*)w)->needsOk() )
                                 text = tr("Click to close this window, discarding changes.");
                             else
                                 text = tr("Click to close this window.");
                             break;
                         case QWSDecoration::Minimize:
                             text = tr("Click to close this window and apply changes.");
                             break;
                         case QWSDecoration::Maximize:
                             if ( w->isMaximized() )
                                 text = tr("Click to make this window moveable.");
                             else
                                 text = tr("Click to make this window use all available screen area.");
                             break;
                         default:
                             break;
                     }
                     QWhatsThis::leaveWhatsThisMode( text );
                     whatsThisTimeout();
                     helpState = 0;
                     return true;
                 }
 #endif
                 if ( inRegion == QPEDecoration::Help ) {
 #ifdef WHATSTHIS_MODE
                     wtTimer->start( 400, TRUE );
 #endif
                     helpState = QWSButton::Clicked|QWSButton::MouseOver;
                     drawButton( w, QPEDecoration::Help, helpState );
                     return true;
                 }
             }
             break;
         case QEvent::MouseButtonRelease:
             if ( helpState & QWSButton::Clicked ) {
                 wtTimer->stop();
                 helpState = 0;
                 drawButton( w, QPEDecoration::Help, helpState );
                 QPoint p = ((QMouseEvent*)e)->globalPos();
                 if ( pointInQpeRegion( w, p ) == QPEDecoration::Help ) {
                     decoration->help( w );
                 }
                 return true;
             }
             break;
         case QEvent::MouseMove:
             if ( helpState & QWSButton::Clicked ) {
                 int oldState = helpState;
                 QPoint p = ((QMouseEvent*)e)->globalPos();
                 if ( pointInQpeRegion( w, p ) == QPEDecoration::Help ) {
                     helpState = QWSButton::Clicked|QWSButton::MouseOver;
                 } else {
                     helpState = 0;
                 }
                 if ( helpState != oldState )
                     drawButton( w, QPEDecoration::Help, helpState );
             }
             break;
         default:
             break;
     }
     return QObject::eventFilter( o, e );
 }
 
 void QPEManager::drawButton( QWidget *w, QPEDecoration::QPERegion r, int state )
 {
     QPainter painter(w);
     QRegion rgn = ((TLWidget *)w)->topExtra()->decor_allocated_region;
     painter.internalGfx()->setWidgetDeviceRegion( rgn );
     painter.setClipRegion(decoration->region(w, w->rect(),QWSDecoration::All));
     decoration->paintButton( &painter, w, (QWSDecoration::Region)r, state );
 }
 
 void QPEManager::drawTitle( QWidget *w )
 {
     QPainter painter(w);
     QRegion rgn = ((TLWidget *)w)->topExtra()->decor_allocated_region;
     painter.internalGfx()->setWidgetDeviceRegion( rgn );
     painter.setClipRegion(decoration->region(w, w->rect(),QWSDecoration::All));
     decoration->paint( &painter, w );
     decoration->paintButton(&painter, w, QWSDecoration::Menu, 0);
     decoration->paintButton(&painter, w, QWSDecoration::Close, 0);
     decoration->paintButton(&painter, w, QWSDecoration::Minimize, 0);
     decoration->paintButton(&painter, w, QWSDecoration::Maximize, 0);
 }
 
 void QPEManager::whatsThisTimeout()
 {
     if ( !QWhatsThis::inWhatsThisMode() ) {
         if ( inWhatsThis ) {
             if ( whatsThis ) {
                 QWidget *w = whatsThis;
                 whatsThis = 0;
                 drawTitle( w );
             }
             wtTimer->stop();
         } else {
             QWhatsThis::enterWhatsThisMode();
             helpState = 0;
             updateActive();
             if ( active ) {
                 whatsThis = active;
                 drawTitle( active );
                 // check periodically to see if we've left whats this mode
                 wtTimer->start( 250 );
             }
         }
         inWhatsThis = !inWhatsThis;
     }
 }
 
 //===========================================================================
 
 static QImage *okImage( int th )
 {
     static QImage *i = 0;
     if ( !i || i->height() != th ) {
         delete i;
         i = new QImage(scaleButton(Resource::loadImage("OKButton"),th));
     }
     return i;
 }
 
 static QImage *closeImage( int th )
 {
     static QImage *i = 0;
     if ( !i || i->height() != th ) {
         delete i;
         i = new QImage(scaleButton(Resource::loadImage("CloseButton"),th));
     }
     return i;
 }
 
 static QImage *helpImage( int th )
 {
     static QImage *i = 0;
     if ( !i || i->height() != th ) {
         delete i;
         i = new QImage(scaleButton(Resource::loadImage("HelpButton"),th));
     }
     return i;
 }
 
 static QImage *maximizeImage( int th )
 {
     static QImage *i = 0;
     if ( !i || i->height() != th ) {
         delete i;
         i = new QImage(scaleButton(Resource::loadImage("MaximizeButton"),th));
     }
     return i;
 }
 
 int WindowDecorationInterface::metric( Metric m, const WindowData *wd ) const
 {
     switch ( m ) {
         case TitleHeight:
             if ( QApplication::desktop()->height() > 320 )
                 return 19;
             else
                 return 15;
         case LeftBorder:
         case RightBorder:
         case TopBorder:
         case BottomBorder:
             return 4;
         case OKWidth:
             return okImage(metric(TitleHeight,wd))->width();
         case CloseWidth:
             return closeImage(metric(TitleHeight,wd))->width();
         case HelpWidth:
             return helpImage(metric(TitleHeight,wd))->width();
         case MaximizeWidth:
             return maximizeImage(metric(TitleHeight,wd))->width();
         case CornerGrabSize:
             return 16;
     }
 
     return 0;
 }
 
 void WindowDecorationInterface::drawArea( Area a, QPainter *p, const WindowData *wd ) const
 {
     int th = metric( TitleHeight, wd );
     QRect r = wd->rect;
 
     switch ( a ) {
         case Border:
             {
                 const QColorGroup &cg = wd->palette.active();
                 qDrawWinPanel(p, r.x()-metric(LeftBorder,wd),
                         r.y()-th-metric(TopBorder,wd),
                         r.width()+metric(LeftBorder,wd)+metric(RightBorder,wd),
                         r.height()+th+metric(TopBorder,wd)+metric(BottomBorder,wd),
                         cg, FALSE, &cg.brush(QColorGroup::Background));
             }
             break;
         case Title:
             {
                 const QColorGroup &cg = wd->palette.active();
                 QBrush titleBrush;
                 QPen   titleLines;
 
                 if ( wd->flags & WindowData::Active ) {
                     titleBrush = cg.brush(QColorGroup::Highlight);
                     titleLines = titleBrush.color().dark();
                 } else {
                     titleBrush = cg.brush(QColorGroup::Background);
                     titleLines = titleBrush.color();
                 }
 
                 p->fillRect( r.x(), r.y()-th, r.width(), th, titleBrush);
 
                 p->setPen( titleLines );
                 for ( int i = r.y()-th; i < r.y(); i += 2 )
                     p->drawLine( r.left(), i, r.right(), i );
             }
             break;
         case TitleText:
             p->drawText( r.x()+3+metric(HelpWidth,wd), r.top()-th,
                 r.width()-metric(OKWidth,wd)-metric(CloseWidth,wd),
                 th, QPainter::AlignVCenter, wd->caption);
             break;
     }
 }
 
 void WindowDecorationInterface::drawButton( Button b, QPainter *p, const WindowData *wd, int x, int y, int, int, QWSButton::State state ) const
 {
     QImage *img = 0;
     switch ( b ) {
         case OK:
             img = okImage(metric(TitleHeight,wd));
             break;
         case Close:
             img = closeImage(metric(TitleHeight,wd));
             break;
         case Help:
             img = helpImage(metric(TitleHeight,wd));
             break;
         case Maximize:
             img = maximizeImage(metric(TitleHeight,wd));
             break;
     }
 
     if ( img ) {
         if ((state & QWSButton::MouseOver) && (state & QWSButton::Clicked))
             p->drawImage(x+2, y+2, *img);
         else
             p->drawImage(x+1, y+1, *img);
     }
 }
 
 QRegion WindowDecorationInterface::mask( const WindowData *wd ) const
 {
     int th = metric(TitleHeight,wd);
     QRect rect( wd->rect );
     QRect r(rect.left() - metric(LeftBorder,wd),
             rect.top() - th - metric(TopBorder,wd),
             rect.width() + metric(LeftBorder,wd) + metric(RightBorder,wd),
             rect.height() + th + metric(TopBorder,wd) + metric(BottomBorder,wd));
     return QRegion(r) - rect;
 }
 
 class DefaultWindowDecoration : public WindowDecorationInterface
 {
 public:
     DefaultWindowDecoration() : ref(0) {}
     QString name() const {
         return "Default";
     }
     QPixmap icon() const {
         return QPixmap();
     }
     QRESULT queryInterface( const QUuid &uuid, QUnknownInterface **iface ) {
         *iface = 0;
         if ( uuid == IID_QUnknown )
             *iface = this;
         else if ( uuid == IID_WindowDecoration )
             *iface = this;
 
         if ( *iface )
             (*iface)->addRef();
         return QS_OK;
     }
     Q_REFCOUNT
 
 private:
     ulong ref;
 };
 
 static WindowDecorationInterface *wdiface = 0;
 static QLibrary *wdlib = 0;
 
 //===========================================================================
 
 QPEDecoration::QPEDecoration()
     : QWSDefaultDecoration()
 {
     if ( wdlib ) {
         wdiface->release();
         wdlib->unload();
         delete wdlib;
         wdlib = 0;
     } else {
         delete wdiface;
     }
     wdiface = new DefaultWindowDecoration;
 
     helpFile = QString(qApp->argv()[0]) + ".html";
     QStringList helpPath = Global::helpPath();
     helpExists = FALSE;
     for (QStringList::ConstIterator it=helpPath.begin(); it!=helpPath.end() && !helpExists; ++it) {
         helpExists = QFile::exists( *it + "/" + helpFile );
             qDebug ( "Checking %s/%s for help: %d", (*it).latin1(), helpFile.latin1(),helpExists);
    }
     qpeManager = new QPEManager( this );
 }
 
 QPEDecoration::QPEDecoration( const QString &plugin )
     : QWSDefaultDecoration()
 {
     if ( wdlib ) {
         wdiface->release();
         wdlib->unload();
         delete wdlib;
         wdlib = 0;
     } else {
         delete wdiface;
     }
     WindowDecorationInterface *iface = 0;
     QString path = QPEApplication::qpeDir() + "/plugins/decorations";
     QLibrary *lib = new QLibrary( path + "/" + plugin );
     if ( lib->queryInterface( IID_WindowDecoration, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
         wdiface = iface;
         wdlib = lib;
     } else {
         delete lib;
         wdiface = new DefaultWindowDecoration;
     }
 
     helpFile = QString(qApp->argv()[0]) + ".html";
     QStringList helpPath = Global::helpPath();
     helpExists = FALSE;
     for (QStringList::ConstIterator it=helpPath.begin(); it!=helpPath.end() && !helpExists; ++it) {
         helpExists = QFile::exists( *it + "/" + helpFile );
             qDebug ( "Checking %s/%s for help: %d", (*it).latin1(), helpFile.latin1(),helpExists); }
     qpeManager = new QPEManager( this );
 }
 
 QPEDecoration::~QPEDecoration()
 {
     delete qpeManager;
 }
 
 const char **QPEDecoration::menuPixmap()
 {
     return (const char **)0;
 }
 
 const char **QPEDecoration::closePixmap()
 {
     return (const char **)qpe_close_xpm;
 }
 
 const char **QPEDecoration::minimizePixmap()
 {
     return (const char **)qpe_accept_xpm;
 }
 
 const char **QPEDecoration::maximizePixmap()
 {
     return (const char **)0;
 }
 
 const char **QPEDecoration::normalizePixmap()
 {
     return (const char **)0;
 }
 
 int QPEDecoration::getTitleHeight( const QWidget *w )
 {
     WindowDecorationInterface::WindowData wd;
     windowData( w, wd );
     return wdiface->metric(WindowDecorationInterface::TitleHeight,&wd);
 }
 
 /*
     If rect is empty, no frame is added. (a hack, really)
 */
 QRegion QPEDecoration::region(const QWidget *widget, const QRect &rect, QWSDecoration::Region type)
 {
     qpeManager->updateActive();
 
     WindowDecorationInterface::WindowData wd;
     windowData( widget, wd );
     wd.rect = rect;
 
     int titleHeight = wdiface->metric(WindowDecorationInterface::TitleHeight,&wd);
     int okWidth = wdiface->metric(WindowDecorationInterface::OKWidth,&wd);
     int closeWidth = wdiface->metric(WindowDecorationInterface::CloseWidth,&wd);
     int helpWidth = wdiface->metric(WindowDecorationInterface::HelpWidth,&wd);
     int grab = wdiface->metric(WindowDecorationInterface::CornerGrabSize,&wd);
 
     QRegion region;
 
     switch ((int)type) {
         case Menu:
             break;
         case Maximize:
             if ( !widget->inherits( "QDialog" ) && qApp->desktop()->width() > 350 ) {
                 int maximizeWidth = wdiface->metric(WindowDecorationInterface::MaximizeWidth,&wd);
                 int left = rect.right() - maximizeWidth - closeWidth;
                 if ( ((HackWidget *)widget)->needsOk() )
                     left -= okWidth;
                 QRect r(left, rect.top() - titleHeight, closeWidth, titleHeight);
                 region = r;
             }
             break;
         case Minimize:
             if ( ((HackWidget *)widget)->needsOk() ) {
                 QRect r(rect.right() - okWidth,
                     rect.top() - titleHeight, okWidth, titleHeight);
                 if (r.left() > rect.left() + titleHeight)
                     region = r;
             }
             break;
         case Close:
             {
                 int left = rect.right() - closeWidth;
                 if ( ((HackWidget *)widget)->needsOk() )
                     left -= okWidth;
                 QRect r(left, rect.top() - titleHeight, closeWidth, titleHeight);
                 region = r;
             }
             break;
             case Title:
             if ( !widget->isMaximized() ) {
                 int width = rect.width() - helpWidth - closeWidth;
                 if ( ((HackWidget *)widget)->needsOk() )
                     width -= okWidth;
                 QRect r(rect.left()+helpWidth, rect.top() - titleHeight,
                         width, titleHeight);
                 if (r.width() > 0)
                     region = r;
             }
             break;
         case Help:
             if ( helpExists || widget->testWFlags(Qt::WStyle_ContextHelp) ) {
                 QRect r(rect.left(), rect.top() - titleHeight,
                           helpWidth, titleHeight);
                 region = r;
             }
             break;
         case Top:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 int b = wdiface->metric(WindowDecorationInterface::TopBorder,&wd);
                 region = m & QRect( br.left()+grab, br.top(),
                                     br.width()-2*grab, b );
             }
             break;
         case Left:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 int b = wdiface->metric(WindowDecorationInterface::LeftBorder,&wd);
                 region = m & QRect( br.left(), br.top()+grab,
                                     b, br.height()-2*grab );
             }
             break;
         case Right:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 int b = wdiface->metric(WindowDecorationInterface::RightBorder,&wd);
                 region = m & QRect( rect.right(), br.top()+grab,
                                     b, br.height()-2*grab );
             }
             break;
         case Bottom:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 int b = wdiface->metric(WindowDecorationInterface::BottomBorder,&wd);
                 region = m & QRect( br.left()+grab, rect.bottom(),
                                     br.width()-2*grab, b );
             }
             break;
         case TopLeft:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 int tb = wdiface->metric(WindowDecorationInterface::TopBorder,&wd);
                 int lb = wdiface->metric(WindowDecorationInterface::LeftBorder,&wd);
                 QRegion crgn( br.left(), br.top(), grab, tb );
                 crgn |= QRect( br.left(), br.top(), lb, grab );
                 region = m & crgn;
             }
             break;
         case TopRight:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 int tb = wdiface->metric(WindowDecorationInterface::TopBorder,&wd);
                 int rb = wdiface->metric(WindowDecorationInterface::RightBorder,&wd);
                 QRegion crgn( br.right()-grab, br.top(), grab, tb );
                 crgn |= QRect( br.right()-rb, br.top(), rb, grab );
                 region = m & crgn;
             }
             break;
         case BottomLeft:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 region = m & QRect( br.left(), br.bottom()-grab, grab, grab );
             }
             break;
         case BottomRight:
             if ( !widget->isMaximized() ) {
                 QRegion m = wdiface->mask(&wd);
                 QRect br = m.boundingRect();
                 region = m & QRect( br.right()-grab, br.bottom()-grab, grab, grab );
             }
             break;
         case All:
             if ( widget->isMaximized() )
                 region = QWSDefaultDecoration::region(widget, rect, type);
             else
                 region = wdiface->mask(&wd) - rect;
             break;
         default:
             region = QWSDefaultDecoration::region(widget, rect, type);
             break;
     }
 
     return region;
 }
 
 void QPEDecoration::paint(QPainter *painter, const QWidget *widget)
 {
     WindowDecorationInterface::WindowData wd;
     windowData( widget, wd );
 
     int titleWidth = getTitleWidth(widget);
     int titleHeight = wdiface->metric(WindowDecorationInterface::TitleHeight,&wd);
 
     QRect rect(widget->rect());
 
     // title bar rect
     QRect tr( rect.left(), rect.top() - titleHeight, rect.width(), titleHeight );
 
 #ifndef QT_NO_PALETTE
     QRegion oldClip = painter->clipRegion();
             painter->setClipRegion( oldClip - QRegion( tr ) );// reduce flicker
     wdiface->drawArea( WindowDecorationInterface::Border, painter, &wd );
     painter->setClipRegion( oldClip );
 
     if (titleWidth > 0) {
         const QColorGroup &cg = widget->palette().active();
         QBrush titleBrush;
         QPen   titlePen;
 
         if ( wd.flags & WindowDecorationInterface::WindowData::Active ) {
             titleBrush = cg.brush(QColorGroup::Highlight);
             titlePen   = cg.color(QColorGroup::HighlightedText);
         } else {
             titleBrush = cg.brush(QColorGroup::Background);
             titlePen   = cg.color(QColorGroup::Text);
         }
 
         wdiface->drawArea( WindowDecorationInterface::Title, painter, &wd );
 
         // Draw caption
         painter->setPen(titlePen);
         QFont f( QApplication::font() );
         f.setWeight( QFont::Bold );
         painter->setFont(f);
         wdiface->drawArea( WindowDecorationInterface::TitleText, painter, &wd );
     }
 #endif //QT_NO_PALETTE
 
     paintButton( painter, widget, (QWSDecoration::Region)Help, 0 );
 }
 
 void QPEDecoration::paintButton(QPainter *painter, const QWidget *w,
                         QWSDecoration::Region type, int state)
 {
     WindowDecorationInterface::Button b;
     switch ((int)type) {
         case Close:
             b = WindowDecorationInterface::Close;
             break;
         case Minimize:
             if ( ((HackWidget *)w)->needsOk() )
                 b = WindowDecorationInterface::OK;
             else if ( helpExists )
                 b = WindowDecorationInterface::Help;
             else
                 return;
             break;
         case Help:
             b = WindowDecorationInterface::Help;
             break;
         case Maximize:
             b = WindowDecorationInterface::Maximize;
             break;
         default:
             return;
     }
 
     WindowDecorationInterface::WindowData wd;
     windowData( w, wd );
 
     int titleHeight = wdiface->metric(WindowDecorationInterface::TitleHeight,&wd);
     QRect rect(w->rect());
     QRect tr( rect.left(), rect.top() - titleHeight, rect.width(), titleHeight );
     QRect brect(region(w, w->rect(), type).boundingRect());
 
     const QColorGroup &cg = w->palette().active();
     if ( wd.flags & WindowDecorationInterface::WindowData::Active )
         painter->setPen( cg.color(QColorGroup::HighlightedText) );
     else
         painter->setPen( cg.color(QColorGroup::Text) );
 
     QRegion oldClip = painter->clipRegion();
     painter->setClipRegion( QRect(brect.x(), tr.y(), brect.width(), tr.height()) ); // reduce flicker
     wdiface->drawArea( WindowDecorationInterface::Title, painter, &wd );
     wdiface->drawButton( b, painter, &wd, brect.x(), brect.y(), brect.width(), brect.height(), (QWSButton::State)state );
     painter->setClipRegion( oldClip );
 }
 
 //#define QPE_DONT_SHOW_TITLEBAR
 
 void QPEDecoration::maximize( QWidget *widget )
 {
 #ifdef QPE_DONT_SHOW_TITLEBAR
     if ( !widget->inherits( "QDialog" ) ) {
         widget->setGeometry( qt_maxWindowRect );
     } else
 #endif
         {
         QWSDecoration::maximize( widget );
     }
 }
 
 #ifndef QT_NO_DIALOG
 class HackDialog : public QDialog
 {
 public:
     void acceptIt() {
         if ( isA( "QMessageBox" ) )
             qApp->postEvent( this, new QKeyEvent( QEvent::KeyPress, Key_Enter, '\n', 0, "\n" ) );
         else
             accept();
     }
 };
 #endif
 
 
 void QPEDecoration::minimize( QWidget *widget )
 {
 #ifndef QT_NO_DIALOG
     // We use the minimize button as an "accept" button.
     if ( widget->inherits( "QDialog" ) ) {
         HackDialog *d = (HackDialog *)widget;
         d->acceptIt();
     }
 #endif
     else if ( ((HackWidget *)widget)->needsOk() ) {
         QSignal s;
         s.connect( widget, SLOT( accept() ) );
         s.activate();
     } else {
         help( widget );
     }
 }
 
 void QPEDecoration::help( QWidget *w )
 {
     if ( helpExists ) {
         Global::execute( "helpbrowser", helpFile );
     } else if ( w && w->testWFlags(Qt::WStyle_ContextHelp) ) {
         QWhatsThis::enterWhatsThisMode();
         QWhatsThis::leaveWhatsThisMode( qApp->tr(
             "<Qt>Comprehensive help is not available for this application, "
             "however there is context-sensitive help.<p>To use context-sensitive help:<p>"
             "<ol><li>click and hold the help button."
             "<li>when the title bar shows <b>What's this...</b>, "
             "click on any control.</ol></Qt>" ) );
     }
 }
 
 void QPEDecoration::windowData( const QWidget *w, WindowDecorationInterface::WindowData &wd ) const
 {
     wd.rect = w->rect();
     if ( qpeManager->whatsThisWidget() == w )
         wd.caption = qApp->tr("What's this..." );
     else
         wd.caption = w->caption();
     wd.palette = qApp->palette();
     wd.flags = 0;
     wd.flags |= w->isMaximized() ? WindowDecorationInterface::WindowData::Maximized : 0;
     wd.flags |= w->testWFlags(Qt::WStyle_Dialog) ? WindowDecorationInterface::WindowData::Dialog : 0;
     const QWidget *active = qpeManager->activeWidget();
     wd.flags |= w == active ? WindowDecorationInterface::WindowData::Active : 0;
     wd.reserved = 1;
 }
 
 /*
 #ifndef QT_NO_POPUPMENU
 QPopupMenu *QPEDecoration::menu(QWSManager*, const QWidget*, const QPoint&)
 {
     return 0;
 }
 #endif
 */
 
 
 
 
 #endif // QT_NO_QWS_QPE_WM_STYLE
-#endif
diff --git a/library/tzselect.cpp b/library/tzselect.cpp
index 9436867..2e5a433 100644
--- a/library/tzselect.cpp
+++ b/library/tzselect.cpp
@@ -1,275 +1,271 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_TZSELECT_INC_LOCAL
 
 #include "tzselect.h"
 #include "resource.h"
 #include "global.h"
 #include "config.h"
 #include <qtoolbutton.h>
 #include <qfile.h>
 #include <stdlib.h>
 
-#ifdef Q_WS_QWS
 #include <qcopchannel_qws.h>
-#endif
 
 class TimeZoneSelectorPrivate
 {
 public:
     TimeZoneSelectorPrivate() : includeLocal(FALSE) {}
     bool includeLocal;
 };
 
 TZCombo::TZCombo( QWidget *p, const char* n )
     : QComboBox( p, n )
 {
     updateZones();
     // check to see if TZ is set, if it is set the current item to that
     QString tz = getenv("TZ");
     if (parent()->inherits("TimeZoneSelector")) {
   if ( ((TimeZoneSelector *)parent())->localIncluded() ) {
       // overide to the 'local' type.
       tz = "None";
   }
     }
     if ( !tz.isNull() ) {
   int n = 0,
             index = 0;
         for ( QStringList::Iterator it=identifiers.begin();
         it!=identifiers.end(); ++it) {
       if ( *it == tz )
     index = n;
       n++;
   }
   setCurrentItem(index);
     } else {
   setCurrentItem(0);
     }
 
 
 
     // listen on QPE/System
-#if defined(Q_WS_QWS)
 #if !defined(QT_NO_COP)
     QCopChannel *channel = new QCopChannel( "QPE/System", this );
     connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
   this, SLOT(handleSystemChannel(const QCString&, const QByteArray&)) );
 #endif
-#endif
 
 
 }
 
 TZCombo::~TZCombo()
 {
 }
 
 void TZCombo::updateZones()
 {
     QString cur = currentText();
     clear();
     identifiers.clear();
     int curix=0;
     QString tz = getenv("TZ");
     bool tzFound = FALSE;
     Config cfg("CityTime");
     cfg.setGroup("TimeZones");
     int listIndex = 0;
     if (parent()->inherits("TimeZoneSelector")) {
   if ( ((TimeZoneSelector *)parent())->localIncluded() ) {
       // overide to the 'local' type.
       identifiers.append( "None" );
       insertItem( tr("None") );
       if ( cur == tr("None"))
     curix = 0;
       listIndex++;
   }
     }
     int cfgIndex = 0;
     while (1) {
   QString zn = cfg.readEntry("Zone"+QString::number(cfgIndex), QString::null);
   if ( zn.isNull() )
       break;
   if ( zn == tz )
       tzFound = TRUE;
   QString nm = cfg.readEntry("ZoneName"+QString::number(cfgIndex));
   identifiers.append(zn);
   insertItem(nm);
   if ( nm == cur )
       curix = listIndex;
   ++cfgIndex;
   ++listIndex;
     }
     if ( !listIndex ) {
         QStringList list = timezoneDefaults();
         for ( QStringList::Iterator it = list.begin(); it!=list.end(); ++it ) {
       QString zn = *it;
       QString nm = *++it;
       if ( zn == tz )
     tzFound = TRUE;
       if ( nm == cur )
     curix = listIndex;
             identifiers.append(zn);
             insertItem(nm);
       ++listIndex;
         }
     }
     for (QStringList::Iterator it=extras.begin(); it!=extras.end(); ++it) {
   insertItem(*it);
   identifiers.append(*it);
   if ( *it == cur )
       curix = listIndex;
   ++listIndex;
     }
     if ( !tzFound && !tz.isEmpty()) {
   int i =  tz.find( '/' );
   QString nm = tz.mid( i+1 ).replace(QRegExp("_"), " ");
   identifiers.append(tz);
   insertItem(nm);
   if ( nm == cur )
       curix = listIndex;
   ++listIndex;
     }
     setCurrentItem(curix);
 }
 
 
 void TZCombo::keyPressEvent( QKeyEvent *e )
 {
     // ### should popup() in Qt 3.0 (it's virtual there)
 //    updateZones();
     QComboBox::keyPressEvent(e);
 }
 
 void TZCombo::mousePressEvent(QMouseEvent*e)
 {
     // ### should popup() in Qt 3.0 (it's virtual there)
 //    updateZones();
     QComboBox::mousePressEvent(e);
 }
 
 QString TZCombo::currZone() const
 {
     return identifiers[currentItem()];
 }
 
 void TZCombo::setCurrZone( const QString& id )
 {
     for (int i=0; i< count(); i++) {
   if ( identifiers[i] == id ) {
       setCurrentItem(i);
       return;
 }
     }
     insertItem(id);
     setCurrentItem( count() - 1);
     identifiers.append(id);
     extras.append(id);
 }
 
 
 
 void TZCombo::handleSystemChannel(const QCString&msg, const QByteArray&)
 {
     if ( msg == "timeZoneListChange()" ) {
   updateZones();
     }
 }
 
 
 TimeZoneSelector::TimeZoneSelector(QWidget* p, const char* n) :
     QHBox(p,n)
 {
     d = new TimeZoneSelectorPrivate();
     // build the combobox before we do any updates...
     cmbTz = new TZCombo( this, "timezone combo" );
 
     cmdTz = new QToolButton( this, "timezone button" );
     cmdTz->setIconSet( Resource::loadIconSet( "citytime_icon" ) );
     cmdTz->setMaximumSize( cmdTz->sizeHint() );
 
     // set up a connection to catch a newly selected item and throw our
     // signal
     QObject::connect( cmbTz, SIGNAL( activated( int ) ),
                       this, SLOT( slotTzActive( int ) ) );
     QObject::connect( cmdTz, SIGNAL( clicked() ),
                       this, SLOT( slotExecute() ) );
 }
 
 TimeZoneSelector::~TimeZoneSelector()
 {
 }
 
 void TimeZoneSelector::setLocalIncluded(bool b)
 {
     d->includeLocal = b;
     cmbTz->updateZones();
 }
 
 bool TimeZoneSelector::localIncluded() const
 {
     return d->includeLocal;
 }
 
 
 QString TimeZoneSelector::currentZone() const
 {
     return cmbTz->currZone();
 }
 
 void TimeZoneSelector::setCurrentZone( const QString& id )
 {
     cmbTz->setCurrZone( id );
 }
 
 void TimeZoneSelector::slotTzActive( int )
 {
     emit signalNewTz( cmbTz->currZone() );
 }
 
 void TimeZoneSelector::slotExecute( void )
 {
     // execute the world time application...
     Global::execute( "citytime" );
 }
 
 QStringList timezoneDefaults( void )
 {
     QStringList tzs;
     // load up the list just like the file format (citytime.cpp)
     tzs.append( "America/New_York" );
     tzs.append( "New York" );
     tzs.append( "America/Los_Angeles" );
     tzs.append( "Los Angeles" );
     tzs.append( "Australia/Brisbane" );
     tzs.append( "Brisbane" );
     tzs.append( "Europe/Berlin" );
     tzs.append( "Berlin" );
     tzs.append( "Asia/Tokyo" );
     tzs.append( "Tokyo" );
     tzs.append( "America/Denver" );
     tzs.append( "Denver" );
     
     return tzs;
 }