Use the improved version to iterate over windows from Qtopia

and include the top level widgets in the to be iterated widgets

2 files changed, 75 insertions, 90 deletions

diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index bf353d4..86aa53d 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -1,410 +1,410 @@
 /**********************************************************************
 ** 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 <stdlib.h>
 #include <unistd.h>
 #include <linux/limits.h> // needed for some toolchains (PATH_MAX)
 #include <qfile.h>
 #ifdef Q_WS_QWS
 #ifndef QT_NO_COP
 #if QT_VERSION <= 231
 #define private public
 #define sendLocally processEvent
 #include "qcopenvelope_qws.h"
 #undef private
 #else
 #include "qcopenvelope_qws.h"
 #endif
 #endif
 #include <qwindowsystem_qws.h>
 #endif
 #include <qtextstream.h>
 #include <qpalette.h>
 #include <qbuffer.h>
 #include <qptrdict.h>
 #include <qregexp.h>
 #include <qdir.h>
 #include <qlabel.h>
 #include <qdialog.h>
 #include <qdragobject.h>
 #include <qtextcodec.h>
 #include <qevent.h>
 #include <qtooltip.h>
 #include <qsignal.h>
 #include <qmainwindow.h>
 #include <qwidgetlist.h>
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #define QTOPIA_INTERNAL_INITAPP
 #include "qpeapplication.h"
 #include "qpestyle.h"
 #include "styleinterface.h"
 #if QT_VERSION >= 300
 #include <qstylefactory.h>
 #else
 #include <qplatinumstyle.h>
 #include <qwindowsstyle.h>
 #include <qmotifstyle.h>
 #include <qmotifplusstyle.h>
 #include "lightstyle.h"
 
 #include <qpe/qlibrary.h>
 #endif
 #include "global.h"
 #include "resource.h"
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
 #include "qutfcodec.h"
 #endif
 #include "config.h"
 #include "network.h"
 #ifdef QWS
 #include "fontmanager.h"
 #endif
 
 #include "alarmserver.h"
 #include "applnk.h"
 #include "qpemenubar.h"
 #include "textcodecinterface.h"
 #include "imagecodecinterface.h"
 
 #include <unistd.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 
 #include "qt_override_p.h"
 
 
 class QPEApplicationData
 {
 public:
         QPEApplicationData ( )
                 : presstimer( 0 ), presswidget( 0 ), rightpressed( false ), kbgrabbed( false ),
                   notbusysent( false ), preloaded( false ), forceshow( false ), nomaximize( false ),
                   keep_running( true ), qpe_main_widget( 0 )
 
         {
                 qcopq.setAutoDelete( TRUE );
         }
 
         int presstimer;
         QWidget* presswidget;
         QPoint presspos;
 
         bool rightpressed : 1;
         bool kbgrabbed    : 1;
         bool notbusysent  : 1;
         bool preloaded    : 1;
         bool forceshow    : 1;
         bool nomaximize   : 1;
         bool keep_running : 1;
 
         QStringList langs;
         QString appName;
         struct QCopRec
         {
                 QCopRec( const QCString &ch, const QCString &msg,
                          const QByteArray &d ) :
                                 channel( ch ), message( msg ), data( d )
                 { }
 
                 QCString channel;
                 QCString message;
                 QByteArray data;
         };
         QWidget* qpe_main_widget;
-        QGuardedPtr<QWidget> lastWidget;
+        QGuardedPtr<QWidget> lastraised;
         QList<QCopRec> qcopq;
         QString styleName;
         QString decorationName;
 
         void enqueueQCop( const QCString &ch, const QCString &msg,
                           const QByteArray &data )
         {
                 qcopq.append( new QCopRec( ch, msg, data ) );
         }
         void sendQCopQ()
         {
                 QCopRec * r;
 #ifndef QT_NO_COP
 
                 for ( QListIterator<QCopRec> it( qcopq ); ( r = it.current() ); ++it )
                         QCopChannel::sendLocally( r->channel, r->message, r->data );
 #endif
 
                 qcopq.clear();
         }
-        static void show_mx(QWidget* mw, bool nomaximize)
+        static void show_mx(QWidget* mw, bool nomaximize,  const QString & = QString::null )
         {
 
             // ugly hack, remove that later after finding a sane solution
             // Addendum: Only Sharp currently has models with high resolution but (physically) small displays,
             // so this is only useful if QT_QWS_SIMPAD is NOT defined. E.g. SIMpad has 800x600 but has
             // a (physically) large enough display to use the small icons
 #ifndef QT_QWS_SIMPAD
             if ( QPEApplication::desktop() ->width() >= 600 && ( mw->inherits("QMainWindow") || mw->isA("QMainWindow") ) )  {
                 ( (  QMainWindow* ) mw )->setUsesBigPixmaps( true );
             }
 #endif
 
                 if ( mw->layout() && mw->inherits("QDialog") ) {
                         QPEApplication::showDialog((QDialog*)mw, nomaximize);
                 }
                 else {
 #ifdef Q_WS_QWS
                         if ( !nomaximize )
                                 mw->showMaximized();
                         else
 #endif
 
                                 mw->show();
                 }
         }
         static bool setWidgetCaptionFromAppName( QWidget* /*mw*/, const QString& /*appName*/, const QString& /*appsPath*/ )
         {
                 /*
                 // This works but disable it for now until it is safe to apply
                 // What is does is scan the .desktop files of all the apps for
                 // the applnk that has the corresponding argv[0] as this program
                 // then it uses the name stored in the .desktop file as the caption
                 // for the main widget. This saves duplicating translations for
                 // the app name in the program and in the .desktop files.
 
                 AppLnkSet apps( appsPath );
 
                 QList<AppLnk> appsList = apps.children();
                 for ( QListIterator<AppLnk> it(appsList); it.current(); ++it ) {
                   if ( (*it)->exec() == appName ) {
                 mw->setCaption( (*it)->name() );
                 return TRUE;
                   }
                 }
                 */
                 return FALSE;
         }
 
 
         void show(QWidget* mw, bool nomax)
         {
                 setWidgetCaptionFromAppName( mw, appName, QPEApplication::qpeDir() + "apps" );
                 nomaximize = nomax;
                 qpe_main_widget = mw;
 #ifndef QT_NO_COP
 
                 sendQCopQ();
 #endif
 
                 if ( preloaded ) {
                         if (forceshow)
                                 show_mx(mw, nomax);
                 }
                 else if ( keep_running ) {
                         show_mx(mw, nomax);
                 }
         }
 
         void loadTextCodecs()
         {
                 QString path = QPEApplication::qpeDir() + "/plugins/textcodecs";
                 QDir dir( path, "lib*.so" );
                 QStringList list;
                 if ( dir. exists ( ))
                     list = dir.entryList();
                 QStringList::Iterator it;
                 for ( it = list.begin(); it != list.end(); ++it ) {
                         TextCodecInterface *iface = 0;
                         QLibrary *lib = new QLibrary( path + "/" + *it );
                         if ( lib->queryInterface( IID_QtopiaTextCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
                                 QValueList<int> mibs = iface->mibEnums();
                                 for (QValueList<int>::ConstIterator i = mibs.begin(); i != mibs.end(); ++i) {
                                         (void)iface->createForMib(*i);
                                         // ### it exists now; need to remember if we can delete it
                                 }
                         }
                         else {
                                 lib->unload();
                                 delete lib;
                         }
                 }
         }
 
         void loadImageCodecs()
         {
                 QString path = QPEApplication::qpeDir() + "/plugins/imagecodecs";
                 QDir dir( path, "lib*.so" );
                 QStringList list;
                 if ( dir. exists ( ))
                     list = dir.entryList();
                 QStringList::Iterator it;
                 for ( it = list.begin(); it != list.end(); ++it ) {
                         ImageCodecInterface *iface = 0;
                         QLibrary *lib = new QLibrary( path + "/" + *it );
                         if ( lib->queryInterface( IID_QtopiaImageCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
                                 QStringList formats = iface->keys();
                                 for (QStringList::ConstIterator i = formats.begin(); i != formats.end(); ++i) {
                                         (void)iface->installIOHandler(*i);
                                         // ### it exists now; need to remember if we can delete it
                                 }
                         }
                         else {
                                 lib->unload();
                                 delete lib;
                         }
                 }
         }
 };
 
 class ResourceMimeFactory : public QMimeSourceFactory
 {
 public:
         ResourceMimeFactory() : resImage( 0 )
         {
                 setFilePath( Global::helpPath() );
                 setExtensionType( "html", "text/html;charset=UTF-8" );
         }
         ~ResourceMimeFactory() {
             delete resImage;
         }
 
         const QMimeSource* data( const QString& abs_name ) const
         {
                 const QMimeSource * r = QMimeSourceFactory::data( abs_name );
                 if ( !r ) {
                         int sl = abs_name.length();
                         do {
                                 sl = abs_name.findRev( '/', sl - 1 );
                                 QString name = sl >= 0 ? abs_name.mid( sl + 1 ) : abs_name;
                                 int dot = name.findRev( '.' );
                                 if ( dot >= 0 )
                                         name = name.left( dot );
                                 QImage img = Resource::loadImage( name );
                                 if ( !img.isNull() ) {
                                     delete resImage;
                                     resImage = new QImageDrag( img );
                                     r = resImage;
                                 }
                         }
                         while ( !r && sl > 0 );
                 }
                 return r;
         }
 private:
     mutable QImageDrag *resImage;
 };
 
 static int& hack(int& i)
 {
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
     // These should be created, but aren't in Qt 2.3.0
     (void)new QUtf8Codec;
     (void)new QUtf16Codec;
 #endif
     return i;
 }
 
 static int muted = 0;
 static int micMuted = 0;
 
 static void setVolume( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "VolumePercent", 50 );
                                 int fd = 0;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         int vol = muted ? 0 : percent;
                                         // set both channels to same volume
                                         vol |= vol << 8;
                                         ioctl( fd, MIXER_WRITE( 0 ), &vol );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }
 
 static void setMic( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "Mic", 50 );
 
                                 int fd = 0;
                                 int mic = micMuted ? 0 : percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_MIC ), &mic );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }
 
 
 static void setBass( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "BassPercent", 50 );
 
                                 int fd = 0;
                                 int bass = percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_BASS ), &bass );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }
 
 
 static void setTreble( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "TreblePercent", 50 );
 
                                 int fd = 0;
                                 int treble = percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_TREBLE ), &treble );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }
 
 
 /*!
   \class QPEApplication qpeapplication.h
@@ -451,533 +451,536 @@ static void setTreble( int t = 0, int percent = -1 )
   \fn void QPEApplication::clientMoused()
 
   \internal
 */
 
 /*!
   \fn void QPEApplication::timeChanged();
   This signal is emitted when the time changes outside the normal
   passage of time, i.e. if the time is set backwards or forwards.
 */
 
 /*!
   \fn void QPEApplication::clockChanged( bool ampm );
 
   This signal is emitted when the user changes the clock's style. If
   \a ampm is TRUE, the user wants a 12-hour AM/PM clock, otherwise,
   they want a 24-hour clock.
 */
 
 /*!
     \fn void QPEApplication::volumeChanged( bool muted )
 
     This signal is emitted whenever the mute state is changed. If \a
     muted is TRUE, then sound output has been muted.
 */
 
 /*!
     \fn void QPEApplication::weekChanged( bool startOnMonday )
 
     This signal is emitted if the week start day is changed. If \a
     startOnMonday is TRUE then the first day of the week is Monday; if
     \a startOnMonday is FALSE then the first day of the week is
     Sunday.
 */
 
 /*!
     \fn void QPEApplication::dateFormatChanged(DateFormat)
 
     This signal is emitted whenever the date format is changed.
 */
 
 /*!
     \fn void QPEApplication::flush()
 
     ###
 */
 
 /*!
   \fn void QPEApplication::reload()
 
 */
 
 
 
 void QPEApplication::processQCopFile()
 {
     QString qcopfn("/tmp/qcop-msg-");
     qcopfn += d->appName; // append command name
 
     QFile f(qcopfn);
     if ( f.open(IO_ReadWrite) ) {
 #ifndef Q_OS_WIN32
         flock(f.handle(), LOCK_EX);
 #endif
         QDataStream ds(&f);
         QCString channel, message;
         QByteArray data;
         while(!ds.atEnd()) {
             ds >> channel >> message >> data;
             d->enqueueQCop(channel,message,data);
         }
         ::ftruncate(f.handle(), 0);
 #ifndef Q_OS_WIN32
         f.flush();
         flock(f.handle(), LOCK_UN);
 #endif
     }
 #endif
 }
 
 
 /*!
   \fn void QPEApplication::appMessage( const QCString& msg, const QByteArray& data )
 
   This signal is emitted when a message is received on this
   application's QPE/Application/<i>appname</i> \link qcop.html
   QCop\endlink channel.
 
   The slot to which you connect this signal uses \a msg and \a data
   in the following way:
 
 \code
      void MyWidget::receive( const QCString& msg, const QByteArray& data )
      {
        QDataStream stream( data, IO_ReadOnly );
        if ( msg == "someMessage(int,int,int)" ) {
             int a,b,c;
             stream >> a >> b >> c;
             ...
        } else if ( msg == "otherMessage(QString)" ) {
            ...
        }
     }
 \endcode
 
   \sa qcop.html
   Note that messages received here may be processed by qpe application
   and emitted as signals, such as flush() and reload().
 */
 
 /*!
   Constructs a QPEApplication just as you would construct
   a QApplication, passing \a argc, \a argv, and \a t.
 
   For applications, \a t should be the default, GuiClient. Only
   the Qtopia server passes GuiServer.
 */
 QPEApplication::QPEApplication( int & argc, char **argv, Type t )
                 : QApplication( hack(argc), argv, t ), pidChannel( 0 )
 {
         d = new QPEApplicationData;
         d->loadTextCodecs();
         d->loadImageCodecs();
                int dw = desktop() ->width();
 
         if ( dw < 200 ) {
                 setFont( QFont( "vera", 8 ) );
                 AppLnk::setSmallIconSize( 10 );
                 AppLnk::setBigIconSize( 28 );
         }
 #ifndef QT_QWS_SIMPAD
         else if ( dw > 600 ) {
                                setFont( QFont( "vera", 16 ) );
                                 AppLnk::setSmallIconSize( 24 );
                 AppLnk::setBigIconSize( 48 );
         }
 #endif
         else if ( dw > 200 ) {
                 setFont( QFont( "vera", 10 ) );
                 AppLnk::setSmallIconSize( 14 );
                 AppLnk::setBigIconSize( 32 );
         }
 
         QMimeSourceFactory::setDefaultFactory( new ResourceMimeFactory );
 
         connect( this, SIGNAL( lastWindowClosed() ), this, SLOT( hideOrQuit() ) );
 
 
         sysChannel = new QCopChannel( "QPE/System", this );
         connect( sysChannel, SIGNAL( received( const QCString &, const QByteArray & ) ),
                  this, SLOT( systemMessage( const QCString &, const QByteArray & ) ) );
 
 /* COde now in initapp */
 #if 0
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 
         QString qcopfn( "/tmp/qcop-msg-" );
         qcopfn += QString( argv[ 0 ] ); // append command name
 
         QFile f( qcopfn );
         if ( f.open( IO_ReadOnly ) ) {
                 flock( f.handle(), LOCK_EX );
         }
 
 
 
         QCString channel = QCString( argv[ 0 ] );
         channel.replace( QRegExp( ".*/" ), "" );
         d->appName = channel;
         channel = "QPE/Application/" + channel;
         pidChannel = new QCopChannel( channel, this );
         connect( pidChannel, SIGNAL( received( const QCString &, const QByteArray & ) ),
                  this, SLOT( pidMessage( const QCString &, const QByteArray & ) ) );
 
         if ( f.isOpen() ) {
                 d->keep_running = FALSE;
                 QDataStream ds( &f );
                 QCString channel, message;
                 QByteArray data;
                 while ( !ds.atEnd() ) {
                         ds >> channel >> message >> data;
                         d->enqueueQCop( channel, message, data );
                 }
 
                 flock( f.handle(), LOCK_UN );
                 f.close();
                 f.remove();
         }
 
         for ( int a = 0; a < argc; a++ ) {
                 if ( qstrcmp( argv[ a ], "-preload" ) == 0 ) {
                         argv[ a ] = argv[ a + 1 ];
                         a++;
                         d->preloaded = TRUE;
                         argc -= 1;
                 }
                 else if ( qstrcmp( argv[ a ], "-preload-show" ) == 0 ) {
                         argv[ a ] = argv[ a + 1 ];
                         a++;
                         d->preloaded = TRUE;
                         d->forceshow = TRUE;
                         argc -= 1;
                 }
         }
 
         /* overide stored arguments */
         setArgs( argc, argv );
 
 #endif
 #else
         initApp( argc, argv );
 #endif
         //  qwsSetDecoration( new QPEDecoration() );
 
 #ifndef QT_NO_TRANSLATION
 
         d->langs = Global::languageList();
         for ( QStringList::ConstIterator it = d->langs.begin(); it != d->langs.end(); ++it ) {
                 QString lang = *it;
 
                 installTranslation( lang + "/libopie.qm");
                 installTranslation( lang + "/libqpe.qm" );
                 installTranslation( lang + "/" + d->appName + ".qm" );
 
 
                 //###language/font hack; should look it up somewhere
 #ifdef QWS
 
                 if ( lang == "ja" || lang == "zh_CN" || lang == "zh_TW" || lang == "ko" ) {
                     QFont fn = FontManager::unicodeFont( FontManager::Proportional );
                     setFont( fn );
                 }
 #endif
         }
 #endif
 
         applyStyle();
 
         if ( type() == GuiServer ) {
                 setVolume();
         }
 
         installEventFilter( this );
 
         QPEMenuToolFocusManager::initialize();
 
 #ifdef QT_NO_QWS_CURSOR
         // if we have no cursor, probably don't want tooltips
         QToolTip::setEnabled( FALSE );
 #endif
 }
 
 
 #ifdef QTOPIA_INTERNAL_INITAPP
 void QPEApplication::initApp( int argc, char **argv )
 {
+    bool initial = pidChannel; // was set to 0 in the initializer
     delete pidChannel;
     d->keep_running = TRUE;
     d->preloaded = FALSE;
     d->forceshow = FALSE;
 
     QCString channel = QCString(argv[0]);
 
     channel.replace(QRegExp(".*/"),"");
     d->appName = channel;
 
     #if QT_VERSION > 235
     qt_fbdpy->setIdentity( channel ); // In Qt/E 2.3.6
     #endif
 
     channel = "QPE/Application/" + channel;
     pidChannel = new QCopChannel( channel, this);
     connect( pidChannel, SIGNAL(received(const QCString &, const QByteArray &)),
             this, SLOT(pidMessage(const QCString &, const QByteArray &)));
 
-    processQCopFile();
-    d->keep_running = d->qcopq.isEmpty();
+    if (!initial) {
+        processQCopFile();
+        d->keep_running = d->qcopq.isEmpty();
+    }
 
     for (int a=0; a<argc; a++) {
         if ( qstrcmp(argv[a],"-preload")==0 ) {
             argv[a] = argv[a+1];
             a++;
             d->preloaded = TRUE;
             argc-=1;
         } else if ( qstrcmp(argv[a],"-preload-show")==0 ) {
             argv[a] = argv[a+1];
             a++;
             d->preloaded = TRUE;
             d->forceshow = TRUE;
             argc-=1;
         }
     }
 
     /* overide stored arguments */
     setArgs(argc, argv);
 
     /* install translation here */
     for ( QStringList::ConstIterator it = d->langs.begin(); it != d->langs.end(); ++it )
         installTranslation( (*it) + "/" + d->appName + ".qm" );
 }
 #endif
 
 
 static QPtrDict<void>* inputMethodDict = 0;
 static void createInputMethodDict()
 {
         if ( !inputMethodDict )
                 inputMethodDict = new QPtrDict<void>;
 }
 
 /*!
   Returns the currently set hint to the system as to whether
   widget \a w has any use for text input methods.
 
 
   \sa setInputMethodHint() InputMethodHint
 */
 QPEApplication::InputMethodHint QPEApplication::inputMethodHint( QWidget * w )
 {
         if ( inputMethodDict && w )
                 return ( InputMethodHint ) ( int ) inputMethodDict->find( w );
         return Normal;
 }
 
 /*!
   \enum QPEApplication::InputMethodHint
 
   \value Normal the application sometimes needs text input (the default).
   \value AlwaysOff the application never needs text input.
   \value AlwaysOn the application always needs text input.
 */
 
 /*!
   Hints to the system that widget \a w has use for text input methods
   as specified by \a mode.
 
   \sa inputMethodHint() InputMethodHint
 */
 void QPEApplication::setInputMethodHint( QWidget * w, InputMethodHint mode )
 {
         createInputMethodDict();
         if ( mode == Normal ) {
                 inputMethodDict->remove
                 ( w );
         }
         else {
                 inputMethodDict->insert( w, ( void* ) mode );
         }
 }
 
 class HackDialog : public QDialog
 {
 public:
         void acceptIt()
         {
                 accept();
         }
         void rejectIt()
         {
                 reject();
         }
 };
 
 
 void QPEApplication::mapToDefaultAction( QWSKeyEvent * ke, int key )
 {
         // specialised actions for certain widgets. May want to
         // add more stuff here.
         if ( activePopupWidget() && activePopupWidget() ->inherits( "QListBox" )
                 && activePopupWidget() ->parentWidget()
                 && activePopupWidget() ->parentWidget() ->inherits( "QComboBox" ) )
                 key = Qt::Key_Return;
 
         if ( activePopupWidget() && activePopupWidget() ->inherits( "QPopupMenu" ) )
                 key = Qt::Key_Return;
 
 #ifdef QWS
 
         ke->simpleData.keycode = key;
 #endif
 }
 
 class HackWidget : public QWidget
 {
 public:
         bool needsOk()
         {
                 return ( getWState() & WState_Reserved1 );
         }
 };
 
 /*!
   \internal
 */
 
 #ifdef QWS
 bool QPEApplication::qwsEventFilter( QWSEvent * e )
 {
         if ( !d->notbusysent && e->type == QWSEvent::Focus ) {
                 if ( qApp->type() != QApplication::GuiServer ) {
                         QCopEnvelope e( "QPE/System", "notBusy(QString)" );
                         e << d->appName;
                 }
                 d->notbusysent = TRUE;
         }
         if ( type() == GuiServer ) {
                 switch ( e->type ) {
                         case QWSEvent::Mouse:
                                 if ( e->asMouse() ->simpleData.state && !QWidget::find( e->window() ) )
                                         emit clientMoused();
                                 break;
                         default:
                                 break;
                 }
         }
         if ( e->type == QWSEvent::Key ) {
                 QWSKeyEvent *ke = ( QWSKeyEvent * ) e;
                 if ( ke->simpleData.keycode == Qt::Key_F33 ) {
                         // Use special "OK" key to press "OK" on top level widgets
                         QWidget * active = activeWindow();
                         QWidget *popup = 0;
                         if ( active && active->isPopup() ) {
                                 popup = active;
                                 active = active->parentWidget();
                         }
                         if ( active && ( int ) active->winId() == ke->simpleData.window &&
                                 !active->testWFlags( WStyle_Customize | WType_Popup | WType_Desktop ) ) {
                                 if ( ke->simpleData.is_press ) {
                                         if ( popup )
                                                 popup->close();
                                         if ( active->inherits( "QDialog" ) ) {
                                                 HackDialog * d = ( HackDialog * ) active;
                                                 d->acceptIt();
                                                 return TRUE;
                                         }
                                         else if ( ( ( HackWidget * ) active ) ->needsOk() ) {
                                                 QSignal s;
                                                 s.connect( active, SLOT( accept() ) );
                                                 s.activate();
                                         }
                                         else {
                                                 // do the same as with the select key: Map to the default action of the widget:
                                                 mapToDefaultAction( ke, Qt::Key_Return );
                                         }
                                 }
                         }
                 }
                 else if ( ke->simpleData.keycode == Qt::Key_F30 ) {
                         // Use special "select" key to do whatever default action a widget has
                         mapToDefaultAction( ke, Qt::Key_Space );
                 }
                 else if ( ke->simpleData.keycode == Qt::Key_Escape &&
                           ke->simpleData.is_press ) {
                         // Escape key closes app if focus on toplevel
                         QWidget * active = activeWindow();
                         if ( active && active->testWFlags( WType_TopLevel ) &&
                                 ( int ) active->winId() == ke->simpleData.window &&
                                 !active->testWFlags( WStyle_Dialog | WStyle_Customize | WType_Popup | WType_Desktop ) ) {
                                 if ( active->inherits( "QDialog" ) ) {
                                         HackDialog * d = ( HackDialog * ) active;
                                         d->rejectIt();
                                         return TRUE;
                                 }
                                 else if ( strcmp( argv() [ 0 ], "embeddedkonsole" ) != 0 ) {
                                         active->close();
                                 }
                         }
                 }
                 else if ( ke->simpleData.keycode >= Qt::Key_F1 && ke->simpleData.keycode <= Qt::Key_F29 ) {
                         // this should be if ( ODevice::inst ( )-> buttonForKeycode ( ... ))
                         // but we cannot access libopie function within libqpe :(
 
                         QWidget * active = activeWindow ( );
                         if ( active && ((int) active-> winId ( ) == ke-> simpleData.window )) {
                                 if ( d-> kbgrabbed ) { // we grabbed the keyboard
                                         QChar ch ( ke-> simpleData.unicode );
                                         QKeyEvent qke ( ke-> simpleData. is_press ? QEvent::KeyPress : QEvent::KeyRelease,
                                                         ke-> simpleData.keycode,
                                                         ch. latin1 ( ),
                                                         ke-> simpleData.modifiers,
                                                         QString ( ch ),
                                                         ke-> simpleData.is_auto_repeat, 1 );
 
                                         QObject *which = QWidget::keyboardGrabber ( );
                                         if ( !which )
                                                 which = QApplication::focusWidget ( );
                                         if ( !which )
                                                 which = QApplication::activeWindow ( );
                                         if ( !which )
                                                 which = qApp;
 
                                         QApplication::sendEvent ( which, &qke );
                                 }
                                 else { // we didn't grab the keyboard, so send the event to the launcher
                                         QCopEnvelope e ( "QPE/Launcher", "deviceButton(int,int,int)" );
                                         e << int( ke-> simpleData.keycode ) << int( ke-> simpleData. is_press ) << int( ke-> simpleData.is_auto_repeat );
                                 }
                         }
                         return true;
                 }
         }
         if ( e->type == QWSEvent::Focus ) {
                 QWSFocusEvent * fe = ( QWSFocusEvent* ) e;
                 if ( !fe->simpleData.get_focus ) {
                         QWidget * active = activeWindow();
                         while ( active && active->isPopup() ) {
                                 active->close();
                                 active = activeWindow();
                         }
                 }
                 else {
                         // make sure our modal widget is ALWAYS on top
                         QWidget *topm = activeModalWidget();
                         if ( topm ) {
                                 topm->raise();
                         }
                 }
                 if ( fe->simpleData.get_focus && inputMethodDict ) {
                         InputMethodHint m = inputMethodHint( QWidget::find( e->window() ) );
                         if ( m == AlwaysOff )
                                 Global::hideInputMethod();
                         if ( m == AlwaysOn )
                                 Global::showInputMethod();
                 }
         }
 
 
         return QApplication::qwsEventFilter( e );
 }
 #endif
 
 /*!
   Destroys the QPEApplication.
@@ -1109,603 +1112,588 @@ void QPEApplication::applyStyle()
         Config config( "qpe" );
         config.setGroup( "Appearance" );
 
     #if QT_VERSION > 233
         // don't block ourselves ...
         Opie::force_appearance = 0;
 
         static QString appname = Opie::binaryName ( );
 
         QStringList ex = config. readListEntry ( "NoStyle", ';' );
         int nostyle = 0;
         for ( QStringList::Iterator it = ex. begin ( ); it != ex. end ( ); ++it ) {
                 if ( QRegExp (( *it ). mid ( 1 ), false, true ). find ( appname, 0 ) >= 0 ) {
                         nostyle = ( *it ). left ( 1 ). toInt ( 0, 32 );
                         break;
                 }
         }
 
         // Widget style
         QString style = config.readEntry( "Style", "FlatStyle" );
 
         // don't set a custom style
         if ( nostyle & Opie::Force_Style )
                 style = "FlatStyle";
 
         internalSetStyle ( style );
 
         // Colors - from /etc/colors/Liquid.scheme
         QColor bgcolor( config.readEntry( "Background", "#E0E0E0" ) );
         QColor btncolor( config.readEntry( "Button", "#96c8fa" ) );
         QPalette pal( btncolor, bgcolor );
         QString color = config.readEntry( "Highlight", "#73adef" );
         pal.setColor( QColorGroup::Highlight, QColor( color ) );
         color = config.readEntry( "HighlightedText", "#FFFFFF" );
         pal.setColor( QColorGroup::HighlightedText, QColor( color ) );
         color = config.readEntry( "Text", "#000000" );
         pal.setColor( QColorGroup::Text, QColor( color ) );
         color = config.readEntry( "ButtonText", "#000000" );
         pal.setColor( QPalette::Active, QColorGroup::ButtonText, QColor( color ) );
         color = config.readEntry( "Base", "#FFFFFF" );
         pal.setColor( QColorGroup::Base, QColor( color ) );
 
         pal.setColor( QPalette::Disabled, QColorGroup::Text,
                       pal.color( QPalette::Active, QColorGroup::Background ).dark() );
 
         setPalette( pal, TRUE );
 
         // Window Decoration
         QString dec = config.readEntry( "Decoration", "Flat" );
 
         // don't set a custom deco
         if ( nostyle & Opie::Force_Decoration )
                 dec = "";
 
         //qDebug ( "Setting Deco: %s -- old %s (%d)", dec.latin1(), d-> decorationName.latin1(), nostyle);
 
         if ( dec != d->decorationName ) {
                 qwsSetDecoration( new QPEDecoration( dec ) );
                 d->decorationName = dec;
         }
 
         // Font
         QString ff = config.readEntry( "FontFamily", font().family() );
         int fs = config.readNumEntry( "FontSize", font().pointSize() );
 
         // don't set a custom font
         if ( nostyle & Opie::Force_Font ) {
                 ff = "Vera";
                 fs = 10;
         }
 
         setFont ( QFont ( ff, fs ), true );
 
         // revert to global blocking policy ...
         Opie::force_appearance = config. readBoolEntry ( "ForceStyle", false ) ? Opie::Force_All : Opie::Force_None;
         Opie::force_appearance &= ~nostyle;
     #endif
 }
 
 void QPEApplication::systemMessage( const QCString& msg, const QByteArray& data )
 {
 #ifdef Q_WS_QWS
         QDataStream stream( data, IO_ReadOnly );
         if ( msg == "applyStyle()" ) {
                 applyStyle();
         }
         else if ( msg == "toggleApplicationMenu()" ) {
                 QWidget *active = activeWindow ( );
 
                 if ( active ) {
                         QPEMenuToolFocusManager *man = QPEMenuToolFocusManager::manager ( );
                         bool oldactive = man-> isActive ( );
 
                         man-> setActive( !man-> isActive() );
 
                         if ( !oldactive && !man-> isActive ( )) { // no menubar to toggle -> try O-Menu
                                 QCopEnvelope e ( "QPE/TaskBar", "toggleStartMenu()" );
                         }
                 }
         }
         else if ( msg == "setDefaultRotation(int)" ) {
                 if ( type() == GuiServer ) {
                         int r;
                         stream >> r;
                         setDefaultRotation( r );
                 }
         }
         else if ( msg == "setCurrentMode(int,int,int)" ) { // Added: 2003-06-11 by Tim Ansell <mithro@mithis.net>
             if ( type() == GuiServer ) {
                 int x, y, depth;
                 stream >> x;
                 stream >> y;
                 stream >> depth;
                 setCurrentMode( x, y, depth );
             }
          }
         else if ( msg == "reset()" ) {
             if ( type() != GuiServer )
                 reset();
         }
         else if ( msg == "setCurrentRotation(int)" ) {
                 int r;
                 stream >> r;
                 setCurrentRotation( r );
          }
         else if ( msg == "shutdown()" ) {
                 if ( type() == GuiServer )
                         shutdown();
         }
         else if ( msg == "quit()" ) {
                 if ( type() != GuiServer )
                         tryQuit();
         }
         else if ( msg == "forceQuit()" ) {
                 if ( type() != GuiServer )
                         quit();
         }
         else if ( msg == "restart()" ) {
                 if ( type() == GuiServer )
                         restart();
         }
         else if ( msg == "language(QString)" ) {
                 if ( type() == GuiServer ) {
                         QString l;
                         stream >> l;
                         QString cl = getenv( "LANG" );
                         if ( cl != l ) {
                                 if ( l.isNull() )
                                         unsetenv( "LANG" );
                                 else
                                         setenv( "LANG", l.latin1(), 1 );
                                 restart();
                         }
                 }
         }
         else if ( msg == "timeChange(QString)" ) {
                 QString t;
                 stream >> t;
                 if ( t.isNull() )
                         unsetenv( "TZ" );
                 else
                         setenv( "TZ", t.latin1(), 1 );
                 // emit the signal so everyone else knows...
                 emit timeChanged();
         }
         else if ( msg == "addAlarm(QDateTime,QCString,QCString,int)" ) {
                 if ( type() == GuiServer ) {
                         QDateTime when;
                         QCString channel, message;
                         int data;
                         stream >> when >> channel >> message >> data;
                         AlarmServer::addAlarm( when, channel, message, data );
                 }
         }
         else if ( msg == "deleteAlarm(QDateTime,QCString,QCString,int)" ) {
                 if ( type() == GuiServer ) {
                         QDateTime when;
                         QCString channel, message;
                         int data;
                         stream >> when >> channel >> message >> data;
                         AlarmServer::deleteAlarm( when, channel, message, data );
                 }
         }
         else if ( msg == "clockChange(bool)" ) {
                 int tmp;
                 stream >> tmp;
                 emit clockChanged( tmp );
         }
         else if ( msg == "weekChange(bool)" ) {
                 int tmp;
                 stream >> tmp;
                 emit weekChanged( tmp );
         }
         else if ( msg == "setDateFormat(DateFormat)" ) {
                 DateFormat tmp;
                 stream >> tmp;
                 emit dateFormatChanged( tmp );
         }
         else if ( msg == "setVolume(int,int)" ) {
                 int t, v;
                 stream >> t >> v;
                 setVolume( t, v );
                 emit volumeChanged( muted );
         }
         else if ( msg == "volumeChange(bool)" ) {
                 stream >> muted;
                 setVolume();
                 emit volumeChanged( muted );
         }
         else if ( msg == "setMic(int,int)" ) { // Added: 2002-02-08 by Jeremy Cowgar <jc@cowgar.com>
                 int t, v;
                 stream >> t >> v;
                 setMic( t, v );
                 emit micChanged( micMuted );
         }
         else if ( msg == "micChange(bool)" ) { // Added: 2002-02-08 by Jeremy Cowgar <jc@cowgar.com>
                 stream >> micMuted;
                 setMic();
                 emit micChanged( micMuted );
         }
         else if ( msg == "setBass(int,int)" ) { // Added: 2002-12-13 by Maximilian Reiss <harlekin@handhelds.org>
                 int t, v;
                 stream >> t >> v;
                 setBass( t, v );
         }
         else if ( msg == "bassChange(bool)" ) { // Added: 2002-12-13 by Maximilian Reiss <harlekin@handhelds.org>
                 setBass();
         }
             else if ( msg == "setTreble(int,int)" ) { // Added: 2002-12-13 by Maximilian Reiss <harlekin@handhelds.org>
                 int t, v;
                 stream >> t >> v;
                 setTreble( t, v );
         }
         else if ( msg == "trebleChange(bool)" ) { // Added: 2002-12-13 by Maximilian Reiss <harlekin@handhelds.org>
                 setTreble();
         } else if ( msg == "getMarkedText()" ) {
         if ( type() == GuiServer ) {
             const ushort unicode = 'C'-'@';
             const int scan = Key_C;
             qwsServer->processKeyEvent( unicode, scan, ControlButton, TRUE, FALSE );
             qwsServer->processKeyEvent( unicode, scan, ControlButton, FALSE, FALSE );
         }
     } else if ( msg == "newChannel(QString)") {
         QString myChannel = "QPE/Application/" + d->appName;
         QString channel;
         stream >> channel;
         if (channel == myChannel) {
             processQCopFile();
             d->sendQCopQ();
         }
     }
 
 
 #endif
 }
 
-#include <qmetaobject.h>
-
-QWidget *QPEApplication::nextWidget(QWidgetList* list,  QWidget* _wid) {
-    QWidget *next = 0;
-    if ( list->isEmpty() || list->count() == 1 )
-        next = _wid;
-    else{
-        QWidget* wid;
-        uint idx   = list->findRef( _wid );
-        uint count = list->count();
-
-        /* one time through the list hacky we may not start with idx but end with it*/
-        for (uint i = (idx + 1)%count; true; i=(i+1)%count ) {
-            wid = list->at(i);
-            if ( wid == _wid ) {
-                next = _wid;
-                break;
-            }else if ((( wid->inherits("QMainWindow") ||
-                        wid->inherits("QDialog") ) &&
-                      wid != qApp->desktop() && !wid->isHidden() ) ||
-                      ( wid == mainWidget() || wid == d->qpe_main_widget ) ){
-                next = wid;
-                break;
-            }
-        }
-    }
 
-    delete list;
-    return next;
-}
+
+
+
 /*!
   \internal
 */
-// ########## raise()ing main window should raise and set active
-// ########## it and then all childen. This belongs in Qt/Embedded
-/*
- * slightly change in behaviour to kill the need of modality in Opie
- * If any of the topLevelWidgets !isFullyObscured we highlight the next
- * top level window
- * 1)If visible and not modal we iterate over the list of top level widgets
- * 2)If modal we we make the modal and its parent toplevel widget visible if available
- * 3)else make topLevel visible
- *
- * send qcop if necessary and save current visible widget if not modal
- */
 bool QPEApplication::raiseAppropriateWindow()
 {
-    bool r = FALSE;
-
-    QWidget *top = d->qpe_main_widget ? d->qpe_main_widget : mainWidget();
-    /* 1. */
-    if ( ( top && (top->isVisible() ) || ( d->lastWidget && d->lastWidget->isVisible() ) ) &&
-         !activeModalWidget() ) {
-        r = TRUE;
-        /*wid will be valid and topLevelWidgets will be deleted properly.. */
-        QWidget *wid = nextWidget( topLevelWidgets(),
-                                   d->lastWidget ? (QWidget*)d->lastWidget : top  );
-        /* keep the size window got but not for root*/
-        if ( top == wid )
-            d->show_mx(top, d->nomaximize );
-        else
-            wid->show();
-
-        wid->raise();
-        wid->setActiveWindow();
-        d->lastWidget = wid;
-    }else if ( activeModalWidget() ) {
-        QWidget*  mod = activeModalWidget();
-        /* get the parent of the modal and its topLevelWidget as background widget */
-        QWidget*  par = activeModalWidget()->parentWidget() ? activeModalWidget()->parentWidget()->topLevelWidget() : 0;
-        if (par ) {
-            if (par == top )
-                d->show_mx(par, d->nomaximize );
-            else
-                par->show();
-            par->raise();
-            par->setActiveWindow();
-        }
-        mod->show();
-        mod->raise();
-        mod->setActiveWindow();
-    }else if (top){
-        d->show_mx(top, d->nomaximize );
-        top->raise();
-        top->setActiveWindow();
-        d->lastWidget = top;
+    bool r=FALSE;
+
+    // 1. Raise the main widget
+    QWidget *top = d->qpe_main_widget;
+    if ( !top ) top = mainWidget();
+
+    if ( top && d->keep_running ) {
+        if ( top->isVisible() )
+            r = TRUE;
+        else if (d->preloaded) {
+            // We are preloaded and not visible.. pretend we just started..
+#ifndef QT_NO_COP
+            QCopEnvelope e("QPE/System", "fastAppShowing(QString)");
+            e << d->appName;
+#endif
+        }
+
+        d->show_mx(top,d->nomaximize, d->appName);
+        top->raise();
+    }
+
+    QWidget *topm = activeModalWidget();
+
+    // 2. Raise any parentless widgets (except top and topm, as they
+    //     are raised before and after this loop).  Order from most
+    //     recently raised as deepest to least recently as top, so
+    //     that repeated calls cycle through widgets.
+    QWidgetList *list = topLevelWidgets();
+    if ( list ) {
+        bool foundlast = FALSE;
+        QWidget* topsub = 0;
+        if ( d->lastraised ) {
+            for (QWidget* w = list->first(); w; w = list->next()) {
+                if ( !w->parentWidget() && w != topm && w->isVisible() && !w->isDesktop() ) {
+                    if ( w == d->lastraised )
+                        foundlast = TRUE;
+                    if ( foundlast ) {
+                        w->raise();
+                        topsub = w;
+                    }
+                }
+            }
+        }
+        for (QWidget* w = list->first(); w; w = list->next()) {
+            if ( !w->parentWidget() && w != topm && w->isVisible() && !w->isDesktop() ) {
+                if ( w == d->lastraised )
+                    break;
+                w->raise();
+                topsub = w;
+            }
+        }
+        d->lastraised = topsub;
+        delete list;
     }
 
-    if (!r && d->preloaded ) {
-        QCopEnvelope e("QPE/System", "fastAppShowing(QString)");
-        e << d->appName;
+    // 3. Raise the active modal widget.
+    if ( topm && topm != top ) {
+        topm->show();
+        topm->raise();
+        // If we haven't already handled the fastAppShowing message
+        if (!top && d->preloaded) {
+#ifndef QT_NO_COP
+            QCopEnvelope e("QPE/System", "fastAppShowing(QString)");
+            e << d->appName;
+#endif
+        }
+        r = FALSE;
     }
 
     return r;
 }
 
 
 void QPEApplication::pidMessage( const QCString& msg, const QByteArray& data)
 {
 #ifdef Q_WS_QWS
 
         if ( msg == "quit()" ) {
                 tryQuit();
         }
         else if ( msg == "quitIfInvisible()" ) {
                 if ( d->qpe_main_widget && !d->qpe_main_widget->isVisible() )
                         quit();
         }
         else if ( msg == "close()" ) {
                 hideOrQuit();
         }
         else if ( msg == "disablePreload()" ) {
                 d->preloaded = FALSE;
                 d->keep_running = TRUE;
                 /* so that quit will quit */
         }
         else if ( msg == "enablePreload()" ) {
                 if (d->qpe_main_widget)
                         d->preloaded = TRUE;
                 d->keep_running = TRUE;
                 /* so next quit won't quit */
         }
         else if ( msg == "raise()" ) {
                 d->keep_running = TRUE;
                 d->notbusysent = FALSE;
                 raiseAppropriateWindow();
                 // Tell the system we're still chugging along...
                 QCopEnvelope e("QPE/System", "appRaised(QString)");
                 e << d->appName;
         }
         else if ( msg == "flush()" ) {
                 emit flush();
                 // we need to tell the desktop
                 QCopEnvelope e( "QPE/Desktop", "flushDone(QString)" );
                 e << d->appName;
         }
         else if ( msg == "reload()" ) {
                 emit reload();
         }
         else if ( msg == "setDocument(QString)" ) {
                 d->keep_running = TRUE;
                 QDataStream stream( data, IO_ReadOnly );
                 QString doc;
                 stream >> doc;
                 QWidget *mw = mainWidget();
                 if ( !mw )
                         mw = d->qpe_main_widget;
                 if ( mw )
                         Global::setDocument( mw, doc );
 
         } else if ( msg == "QPEProcessQCop()" ) {
             processQCopFile();
             d->sendQCopQ();
         }else
         {
             bool p = d->keep_running;
             d->keep_running = FALSE;
             emit appMessage( msg, data);
             if ( d->keep_running ) {
                 d->notbusysent = FALSE;
                 raiseAppropriateWindow();
                 if ( !p ) {
                     // Tell the system we're still chugging along...
 #ifndef QT_NO_COP
                     QCopEnvelope e("QPE/System", "appRaised(QString)");
                     e << d->appName;
 #endif
                 }
             }
             if ( p )
                 d->keep_running = p;
         }
 #endif
 }
 
 
 /*!
   Sets widget \a mw as the mainWidget() and shows it. For small windows,
   consider passing TRUE for \a nomaximize rather than the default FALSE.
 
   \sa showMainDocumentWidget()
 */
 void QPEApplication::showMainWidget( QWidget* mw, bool nomaximize )
 {
             d->show(mw, nomaximize );
 }
 
 /*!
   Sets widget \a mw as the mainWidget() and shows it. For small windows,
   consider passing TRUE for \a nomaximize rather than the default FALSE.
 
   This calls designates the application as
   a \link docwidget.html document-oriented\endlink application.
 
   The \a mw widget \e must have this slot: setDocument(const QString&).
 
   \sa showMainWidget()
 */
 void QPEApplication::showMainDocumentWidget( QWidget* mw, bool nomaximize )
 {
         if ( mw && argc() == 2 )
                 Global::setDocument( mw, QString::fromUtf8(argv()[1]) );
 
 
         d->show(mw, nomaximize );
 }
 
 
 /*!
   If an application is started via a \link qcop.html QCop\endlink
   message, the application will process the \link qcop.html
   QCop\endlink message and then quit. If the application calls this
   function while processing a \link qcop.html QCop\endlink message,
   after processing its outstanding \link qcop.html QCop\endlink
   messages the application will start 'properly' and show itself.
 
   \sa keepRunning()
 */
 void QPEApplication::setKeepRunning()
 {
         if ( qApp && qApp->inherits( "QPEApplication" ) ) {
                 QPEApplication * qpeApp = ( QPEApplication* ) qApp;
                 qpeApp->d->keep_running = TRUE;
         }
 }
 
 /*!
   Returns TRUE if the application will quit after processing the
   current list of qcop messages; otherwise returns FALSE.
 
   \sa setKeepRunning()
 */
 bool QPEApplication::keepRunning() const
 {
         return d->keep_running;
 }
 
 /*!
   \internal
 */
 void QPEApplication::internalSetStyle( const QString &style )
 {
 #if QT_VERSION >= 300
         if ( style == "QPE" ) {
                 setStyle( new QPEStyle );
         }
         else {
                 QStyle *s = QStyleFactory::create( style );
                 if ( s )
                         setStyle( s );
         }
 #else
         if ( style == "Windows" ) {
                 setStyle( new QWindowsStyle );
         }
         else if ( style == "QPE" ) {
                 setStyle( new QPEStyle );
         }
         else if ( style == "Light" ) {
                 setStyle( new LightStyle );
         }
 #ifndef QT_NO_STYLE_PLATINUM
         else if ( style == "Platinum" ) {
                 setStyle( new QPlatinumStyle );
         }
 #endif
 #ifndef QT_NO_STYLE_MOTIF
         else if ( style == "Motif" ) {
                 setStyle( new QMotifStyle );
         }
 #endif
 #ifndef QT_NO_STYLE_MOTIFPLUS
         else if ( style == "MotifPlus" ) {
                 setStyle( new QMotifPlusStyle );
         }
 #endif
 
         else {
                 QStyle *sty = 0;
                 QString path = QPEApplication::qpeDir ( ) + "/plugins/styles/";
 
                 if ( style. find ( ".so" ) > 0 )
                         path += style;
                 else
                         path = path + "lib" + style. lower ( ) + ".so"; // compatibility
 
                 static QLibrary *lastlib = 0;
                 static StyleInterface *lastiface = 0;
 
                 QLibrary *lib = new QLibrary ( path );
                 StyleInterface *iface = 0;
 
                 if (( lib-> queryInterface ( IID_Style, ( QUnknownInterface ** ) &iface ) == QS_OK ) && iface )
                         sty = iface-> style ( );
 
                 if ( sty ) {
                         setStyle ( sty );
 
                         if ( lastiface )
                                 lastiface-> release ( );
                         lastiface = iface;
 
                         if ( lastlib ) {
                                 lastlib-> unload ( );
                                 delete lastlib;
                         }
                         lastlib = lib;
                 }
                 else {
                         if ( iface )
                                 iface-> release ( );
                         delete lib;
 
                         setStyle ( new LightStyle ( ));
                 }
         }
 #endif
 }
 
 /*!
   \internal
 */
 void QPEApplication::prepareForTermination( bool willrestart )
 {
         if ( willrestart ) {
                 // Draw a big wait icon, the image can be altered in later revisions
                 //  QWidget *d = QApplication::desktop();
                 QImage img = Resource::loadImage( "launcher/new_wait" );
                 QPixmap pix;
                 pix.convertFromImage( img.smoothScale( 1 * img.width(), 1 * img.height() ) );
                 QLabel *lblWait = new QLabel( 0, "wait hack!", QWidget::WStyle_Customize |
                                               QWidget::WStyle_NoBorder | QWidget::WStyle_Tool );
                 lblWait->setPixmap( pix );
                 lblWait->setAlignment( QWidget::AlignCenter );
                 lblWait->show();
                 lblWait->showMaximized();
         }
 #ifndef SINGLE_APP
         { QCopEnvelope envelope( "QPE/System", "forceQuit()" );
         }
         processEvents(); // ensure the message goes out.
         sleep( 1 ); // You have 1 second to comply.
 #endif
 }
 
 /*!
   \internal
diff --git a/library/qpeapplication.h b/library/qpeapplication.h
index 69e0058..729cf2b 100644
--- a/library/qpeapplication.h
+++ b/library/qpeapplication.h
@@ -1,209 +1,206 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef __QPE_APPLICATION_H__
 #define __QPE_APPLICATION_H__
 
 #include <stdlib.h> // for setenv()
 
 #include <qglobal.h>
 #include <qapplication.h>
 #include <qdialog.h>
 #include <qwsdisplay_qws.h>
 #if defined(_WS_QWS_) && !defined(Q_WS_QWS)
 #define Q_WS_QWS
 #endif
 #include "qpedecoration_qws.h"
 #include "timestring.h"
 
 class QCopChannel;
 class QPEApplicationData;
 class QWSEvent;
 class QWSKeyEvent;
 
 
 class QPEApplication : public QApplication
 {
     Q_OBJECT
 public:
     QPEApplication( int& argc, char **argv, Type=GuiClient );
     ~QPEApplication();
 
     static QString qpeDir();
     static QString documentDir();
     void applyStyle();
     void reset();
     static int defaultRotation();
     static void setDefaultRotation(int r);
     static void setCurrentRotation(int r);
     static void setCurrentMode(int x, int y, int depth );
     static void grabKeyboard();
     static void ungrabKeyboard();
 
     enum StylusMode {
         LeftOnly,
         RightOnHold
         // RightOnHoldLeftDelayed, etc.
     };
     static void setStylusOperation( QWidget*, StylusMode );
     static StylusMode stylusOperation( QWidget* );
 
     enum InputMethodHint {
         Normal,
         AlwaysOff,
         AlwaysOn
     };
 
     enum screenSaverHint {
         Disable = 0,
         DisableLightOff = 1,
         DisableSuspend = 2,
         Enable = 100
     };
 
     static void setInputMethodHint( QWidget *, InputMethodHint );
     static InputMethodHint inputMethodHint( QWidget * );
 
     void showMainWidget( QWidget*, bool nomax=FALSE );
     void showMainDocumentWidget( QWidget*, bool nomax=FALSE );
     static void showDialog( QDialog*, bool nomax=FALSE );
     static int execDialog( QDialog*, bool nomax=FALSE );
     /* Merge setTempScreenSaverMode */
 #ifdef QTOPIA_INTERNAL_INITAPP
     void initApp( int argv, char **argv );
 #endif
 
     static void setKeepRunning();
     bool keepRunning() const;
 
     bool keyboardGrabbed() const;
 
     int exec();
 
 signals:
     void clientMoused();
     void timeChanged();
     void clockChanged( bool pm );
     void micChanged( bool muted );
     void volumeChanged( bool muted );
     void appMessage( const QCString& msg, const QByteArray& data);
     void weekChanged( bool startOnMonday );
     void dateFormatChanged( DateFormat );
     void flush();
     void reload();
     /* linkChanged signal */
 
 private slots:
     void systemMessage( const QCString &msg, const QByteArray &data );
     void pidMessage( const QCString &msg, const QByteArray &data );
     void removeSenderFromStylusDict();
     void hideOrQuit();
 
-private:
-    QWidget *nextWidget( QWidgetList*, QWidget* );
-
 protected:
     bool qwsEventFilter( QWSEvent * );
     void internalSetStyle( const QString &style );
     void prepareForTermination(bool willrestart);
     virtual void restart();
     virtual void shutdown();
     bool eventFilter( QObject *, QEvent * );
     void timerEvent( QTimerEvent * );
     bool raiseAppropriateWindow();
     virtual void tryQuit();
 #if QT_VERSION > 233
     virtual void polish ( QWidget * ); // this is actually implemented in qt_override.cpp (!)
 #endif
 private:
 #ifndef QT_NO_TRANSLATION
     void installTranslation( const QString& baseName );
 #endif
     void mapToDefaultAction( QWSKeyEvent *ke, int defKey );
     void processQCopFile();
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QCopChannel *sysChannel;
     QCopChannel *pidChannel;
 #endif
     QPEApplicationData *d;
 
     bool reserved_sh;
 
 
 
 };
 
 inline void QPEApplication::showDialog( QDialog* d, bool nomax )
 {
     QSize sh = d->sizeHint();
     int w = QMAX(sh.width(),d->width());
     int h = QMAX(sh.height(),d->height());
     if ( !nomax
             && ( w > qApp->desktop()->width()*3/4
                  || h > qApp->desktop()->height()*3/4 ) )
     {
         d->showMaximized();
     } else {
         d->resize(w,h);
         d->show();
     }
 }
 
 inline int QPEApplication::execDialog( QDialog* d, bool nomax )
 {
     showDialog(d,nomax);
     return d->exec();
 }
 
 enum Transformation { Rot0, Rot90, Rot180, Rot270 }; /* from qgfxtransformed_qws.cpp */
 
 inline int TransToDeg ( Transformation t )
 {
         int d = static_cast<int>( t );
         return d * 90;
 }
 
 inline Transformation DegToTrans ( int d )
 {
         Transformation t = static_cast<Transformation>( d / 90 );
         return t;
 }
 
 /*
  * Set current rotation of Opie, and rotation for newly started apps.
  * Differs from setDefaultRotation in that 1) it rotates currently running apps,
  * and 2) does not set deforient or save orientation to qpe.conf.
  */
 
 inline void QPEApplication::setCurrentRotation( int r )
 {
     // setTransformation has been introduced in Qt/Embedded 2.3.4 snapshots
     // for compatibility with the SharpROM use fallback to setDefaultTransformation()
 #if QT_VERSION > 233
     Transformation e = DegToTrans( r );
     ::setenv( "QWS_DISPLAY", QString( "Transformed:Rot%1:0" ).arg( r ).latin1(), 1 );
     qApp->desktop()->qwsDisplay()->setTransformation( e );
 #else
     setDefaultRotation( r );
 #endif
 }
 
 
 #endif