1 files changed, 54 insertions, 67 deletions

diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index b26933b..e7e210a 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -31,144 +31,143 @@
 #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 "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 ), kbgrabber( 0 ),
-                        rightpressed( FALSE ),  kbregrab( FALSE ), notbusysent( FALSE ), preloaded( FALSE ),
-                        forceshow( FALSE ), nomaximize( FALSE ), keep_running( TRUE ), qpe_main_widget( 0 )
+        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;
-        int kbgrabber;
-        QString kbgrabber_appname;
         QPoint presspos;
 
         bool rightpressed : 1;
-        bool kbregrab     : 1;
+        bool kbgrabbed    : 1;
         bool notbusysent  : 1;
         bool preloaded    : 1;
         bool forceshow    : 1;
         bool nomaximize   : 1;
         bool keep_running : 1;
 
         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;
         QList<QCopRec> qcopq;
 
         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)
         {
                 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 );
 
@@ -694,215 +693,228 @@ 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 ) {
-                if ( d->kbgrabber == 1 )
-                        return TRUE;
                 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();
                                 }
                         }
                 }
-
-#if QT_VERSION < 231
-                // Filter out the F4/Launcher key from apps
-                // ### The launcher key may not always be F4 on all devices
-                if ( ( ( QWSKeyEvent * ) e ) ->simpleData.keycode == Qt::Key_F4 )
-                        return TRUE;
-#endif
-
+                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;
-                QWidget* nfw = QWidget::find( e->window() );
                 if ( !fe->simpleData.get_focus ) {
                         QWidget * active = activeWindow();
                         while ( active && active->isPopup() ) {
                                 active->close();
                                 active = activeWindow();
                         }
-                        if ( !nfw && d->kbgrabber == 2 ) {
-                                ungrabKeyboard();
-                                d->kbregrab = TRUE; // want kb back when we're active
-                        }
                 }
                 else {
                         // make sure our modal widget is ALWAYS on top
                         QWidget *topm = activeModalWidget();
                         if ( topm ) {
                                 topm->raise();
                         }
-                        if ( d->kbregrab ) {
-                                grabKeyboard();
-                                d->kbregrab = FALSE;
-                        }
                 }
                 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.
 */
 QPEApplication::~QPEApplication()
 {
         ungrabKeyboard();
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
         // Need to delete QCopChannels early, since the display will
         // be gone by the time we get to ~QObject().
         delete sysChannel;
         delete pidChannel;
 #endif
 
         delete d;
 }
 
 /*!
   Returns <tt>$OPIEDIR/</tt>.
 */
 QString QPEApplication::qpeDir()
 {
         const char * base = getenv( "OPIEDIR" );
         if ( base )
                 return QString( base ) + "/";
 
         return QString( "../" );
 }
 
 /*!
   Returns the user's current Document directory. There is a trailing "/".
   .. well, it does now,, and there's no trailing '/'
 */
 QString QPEApplication::documentDir()
 {
         const char* base = getenv( "HOME");
         if ( base )
                 return QString( base ) + "/Documents";
 
         return QString( "../Documents" );
 }
 
 static int deforient = -1;
 
 /*!
   \internal
 */
 int QPEApplication::defaultRotation()
 {
         if ( deforient < 0 ) {
                 QString d = getenv( "QWS_DISPLAY" );
                 if ( d.contains( "Rot90" ) ) {
@@ -972,163 +984,165 @@ void QPEApplication::applyStyle()
         // don't set a custom style
         if ( nostyle & Opie::Force_Style )
                 style = "Light";
 
         internalSetStyle ( style );
 
         // Colors
         QColor bgcolor( config.readEntry( "Background", "#E5E1D5" ) );
         QColor btncolor( config.readEntry( "Button", "#D6CDBB" ) );
         QPalette pal( btncolor, bgcolor );
         QString color = config.readEntry( "Highlight", "#800000" );
         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", "Qtopia" );
 
         // 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 = "Helvetica";
                 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;
 }
 
 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 == "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 == "grabKeyboard(QString)" ) {
-                QString who;
-                stream >> who;
-                if ( who.isEmpty() )
-                        d->kbgrabber = 0;
-                else if ( who != d->appName )
-                        d->kbgrabber = 1;
-                else
-                        d->kbgrabber = 2;
-                        
-                d-> kbgrabber_appname = who;
-        }
         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 == "execute(QString)" ) {
                 if ( type() == GuiServer ) {
                         QString t;
                         stream >> t;
                         Global::execute( t );
                 }
         }
         else if ( msg == "execute(QString,QString)" ) {
                 if ( type() == GuiServer ) {
                         QString t, d;
                         stream >> t >> d;
                         Global::execute( t, d );
                 }
         }
         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;
@@ -1563,180 +1577,153 @@ bool QPEApplication::eventFilter( QObject *o, QEvent *e )
                                                                            new QMouseEvent( QEvent::MouseButtonRelease, me->pos(),
                                                                                             RightButton, LeftButton + RightButton ) );
                                                                 // Left released, off-widget
                                                                 postEvent( d->presswidget,
                                                                            new QMouseEvent( QEvent::MouseMove, QPoint( -1, -1),
                                                                                             LeftButton, LeftButton ) );
                                                                 postEvent( d->presswidget,
                                                                            new QMouseEvent( QEvent::MouseButtonRelease, QPoint( -1, -1),
                                                                                             LeftButton, LeftButton ) );
                                                                 d->rightpressed = FALSE;
                                                                 return TRUE; // don't send the real Left release
                                                         }
                                                 }
                                                 break;
                                         default:
                                                 break;
                                 }
                                 break;
                         default:
                                 ;
                 }
         }
         else if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
                 QKeyEvent *ke = (QKeyEvent *)e;
                 if ( ke->key() == Key_Enter ) {
                         if ( o->isA( "QRadioButton" ) || o->isA( "QCheckBox" ) ) {
                                 postEvent( o, new QKeyEvent( e->type(), Key_Space, ' ',
                                                              ke->state(), " ", ke->isAutoRepeat(), ke->count() ) );
                                 return TRUE;
                         }
                 }
         }
         return FALSE;
 }
 
 /*!
   \reimp
 */
 void QPEApplication::timerEvent( QTimerEvent *e )
 {
         if ( e->timerId() == d->presstimer && d->presswidget ) {
                 // Right pressed
                 postEvent( d->presswidget,
                            new QMouseEvent( QEvent::MouseButtonPress, d->presspos,
                                             RightButton, LeftButton ) );
                 killTimer( d->presstimer );
                 d->presstimer = 0;
                 d->rightpressed = TRUE;
         }
 }
 
 void QPEApplication::removeSenderFromStylusDict()
 {
         stylusDict->remove
         ( ( void* ) sender() );
         if ( d->presswidget == sender() )
                 d->presswidget = 0;
 }
 
 /*!
   \internal
 */
 bool QPEApplication::keyboardGrabbed() const
 {
-        return d->kbgrabber;
-}
-
-/*!
-  \internal
-*/
-QString QPEApplication::keyboardGrabbedBy() const
-{
-        return d->kbgrabber_appname;
+        return d->kbgrabbed;
 }
 
 
 /*!
   Reverses the effect of grabKeyboard(). This is called automatically
   on program exit.
 */
 void QPEApplication::ungrabKeyboard()
 {
-        QPEApplicationData * d = ( ( QPEApplication* ) qApp ) ->d;
-        if ( d->kbgrabber == 2 ) {
-#ifndef QT_NO_COP
-                QCopEnvelope e( "QPE/System", "grabKeyboard(QString)" );
-                e << QString::null;
-#endif
-
-                d->kbregrab = FALSE;
-                d->kbgrabber = 0;
-        }
+        ((QPEApplication *) qApp )-> d-> kbgrabbed = false;
 }
 
 /*!
   Grabs the physical keyboard keys, e.g. the application's launching
   keys. Instead of launching applications when these keys are pressed
   the signals emitted are sent to this application instead. Some games
   programs take over the launch keys in this way to make interaction
   easier.
 
   \sa ungrabKeyboard()
 */
 void QPEApplication::grabKeyboard()
 {
-        QPEApplicationData * d = ( ( QPEApplication* ) qApp ) ->d;
-        if ( qApp->type() == QApplication::GuiServer )
-                d->kbgrabber = 0;
-        else {
-#ifndef QT_NO_COP
-                QCopEnvelope e( "QPE/System", "grabKeyboard(QString)" );
-                e << d->appName;
-#endif
-
-                d->kbgrabber = 2; // me
-        }
+        ((QPEApplication *) qApp )-> d-> kbgrabbed = true;
 }
 
 /*!
   \reimp
 */
 int QPEApplication::exec()
 {
 #ifndef QT_NO_COP
         d->sendQCopQ();
 #endif
 
         if ( d->keep_running )
                 //|| d->qpe_main_widget && d->qpe_main_widget->isVisible() )
                 return QApplication::exec();
 
 #ifndef QT_NO_COP
 
         {
                 QCopEnvelope e( "QPE/System", "closing(QString)" );
                 e << d->appName;
         }
 #endif
         processEvents();
         return 0;
 }
 
 /*!
   \internal
   External request for application to quit.  Quits if possible without
   loosing state.
 */
 void QPEApplication::tryQuit()
 {
         if ( activeModalWidget() || strcmp( argv() [ 0 ], "embeddedkonsole" ) == 0 )
                 return ; // Inside modal loop or konsole. Too hard to save state.
 #ifndef QT_NO_COP
 
         {
                 QCopEnvelope e( "QPE/System", "closing(QString)" );
                 e << d->appName;
         }
 #endif
         processEvents();
 
         quit();
 }
 
 /*!
   \internal
   User initiated quit.  Makes the window 'Go Away'.  If preloaded this means
   hiding the window.  If not it means quitting the application.
   As this is user initiated we don't need to check state.
 */
 void QPEApplication::hideOrQuit()
 {
         processEvents();
 
         // If we are a preloaded application we don't actually quit, so emit
         // a System message indicating we're quasi-closing.
         if ( d->preloaded && d->qpe_main_widget )
 #ifndef QT_NO_COP
 
         {
                 QCopEnvelope e("QPE/System", "fastAppHiding(QString)" );