flag ms_is_starting

it will be set true until the main eventloop is reached.
Check it with ServerApp::isStarting()

2 files changed, 17 insertions, 1 deletions

diff --git a/core/launcher/serverapp.cpp b/core/launcher/serverapp.cpp
index 11381e6..f7c2341 100644
--- a/core/launcher/serverapp.cpp
+++ b/core/launcher/serverapp.cpp
@@ -201,151 +201,152 @@ bool KeyFilter::checkButtonAction(bool db, int keycode,  int press, int autoRepe
         if (button && !autoRepeat) {
             if ( held_tid ) {
                 killTimer(held_tid);
                 held_tid = 0;
             }
             if ( button->heldAction().isNull() ) {
                 if ( press )
                     emit activate(button, FALSE);
             } else if ( press ) {
                 heldButton = button;
                 held_tid = startTimer( ODevice::inst ()->buttonHoldTime () );
             } else if ( heldButton ) {
                 heldButton = 0;
                 emit activate(button, FALSE);
             }
             QWSServer::screenSaverActivate(FALSE);
             return TRUE;
         }
         return false;
     }
     if ( keycode == HardKey_Suspend ) {
         if ( press ) emit power();
         return TRUE;
     }
     if ( keycode == HardKey_Backlight ) {
         if ( press ) emit backlight();
         return TRUE;
     }
     if ( keycode == Key_F32 ) {
 #ifndef QT_NO_COP
         if ( press ) QCopEnvelope e( "QPE/Desktop", "startSync()" );
 #endif
         return TRUE;
     }
     if ( keycode == Key_F31 ) {
         if ( press ) emit symbol();
         QWSServer::screenSaverActivate(FALSE);
         return TRUE;
     }
 
     if ( keycode == Key_NumLock )
         if ( press ) emit numLockStateToggle();
 
     if ( keycode == Key_CapsLock )
         if ( press ) emit capsLockStateToggle();
 
     if ( serverApp )
         serverApp->keyClick(keycode,press,autoRepeat);
 
     return FALSE;
 }
 
 enum MemState { MemUnknown, MemVeryLow, MemLow, MemNormal } memstate=MemUnknown;
 
 #if defined(QPE_HAVE_MEMALERTER)
 QPE_MEMALERTER_IMPL
 #endif
 
 
 
 //---------------------------------------------------------------------------
 
 bool ServerApplication::doRestart = FALSE;
 bool ServerApplication::allowRestart = TRUE;
+bool ServerApplication::ms_is_starting  = TRUE;
 
 void ServerApplication::switchLCD( bool on ) {
     if ( !qApp )
         return;
 
     ServerApplication *dapp = ServerApplication::me() ;
 
     if ( !dapp-> m_screensaver )
         return;
 
     if ( on ) {
         dapp-> m_screensaver-> setDisplayState ( true );
         dapp-> m_screensaver-> setBacklight ( -3 );
     }else
         dapp-> m_screensaver-> setDisplayState ( false );
 
 
 }
 
 ServerApplication::ServerApplication( int& argc, char **argv, Type t )
     : QPEApplication( argc, argv, t )
 {
-
+    ms_is_starting = true;
 
     // We know we'll have lots of cached pixmaps due to App/DocLnks
     QPixmapCache::setCacheLimit(512);
 
     m_ps = new PowerStatus;
     m_ps_last = new PowerStatus;
     pa = new DesktopPowerAlerter( 0 );
 
     m_apm_timer = new QTimer( this );
     connect(m_apm_timer, SIGNAL( timeout() ),
             this, SLOT( apmTimeout() ) );
 
     reloadPowerWarnSettings();
 
     QCopChannel *channel = new QCopChannel( "QPE/System", this );
     connect(channel, SIGNAL(received( const QCString&, const QByteArray& ) ),
             this, SLOT(systemMessage(const QCString&, const QByteArray& ) ) );
 
     channel = new QCopChannel("QPE/Launcher", this );
     connect(channel, SIGNAL(received( const QCString&, const QByteArray& ) ),
             this, SLOT(launcherMessage( const QCString&, const QByteArray& ) ) );
 
     m_screensaver = new OpieScreenSaver();
     m_screensaver->setInterval( -1 );
     QWSServer::setScreenSaver( m_screensaver );
 
     connect( qApp, SIGNAL( volumeChanged( bool ) ),
              this, SLOT( rereadVolumes() ) );
 
 
     /* ### PluginLoader libqtopia SafeMode */
 #if 0
     if ( PluginLoader::inSafeMode() )
 	QTimer::singleShot(500, this, SLOT(showSafeMode()) );
     QTimer::singleShot(20*1000, this, SLOT(clearSafeMode()) );
 #endif
 
     kf = new KeyFilter(this);
 
     connect( kf, SIGNAL(launch()), this, SIGNAL(launch()) );
     connect( kf, SIGNAL(power()), this, SIGNAL(power()) );
     connect( kf, SIGNAL(backlight()), this, SIGNAL(backlight()) );
     connect( kf, SIGNAL(symbol()), this, SIGNAL(symbol()));
     connect( kf, SIGNAL(numLockStateToggle()), this,SIGNAL(numLockStateToggle()));
     connect( kf, SIGNAL(capsLockStateToggle()), this,SIGNAL(capsLockStateToggle()));
     connect( kf, SIGNAL(activate(const Opie::ODeviceButton*,bool)),
 	    this,SIGNAL(activate(const Opie::ODeviceButton*,bool)));
 
 
     connect( kf, SIGNAL(backlight()), this, SLOT(toggleLight()) );
 
     connect( this, SIGNAL(power() ),
              SLOT(togglePower() ) );
 
     rereadVolumes();
 
     serverApp = this;
 
     apmTimeout();
     grabKeyboard();
 
     /* make sure the event filter is installed */
     const Opie::ODeviceButton* but = Opie::ODevice::inst()->buttonForKeycode( -1 );
 }
@@ -785,66 +786,77 @@ void ServerApplication::checkMemory()
 
     if(existingMessage)
 	return; // don't show a second message while still on first
 
     existingMessage = TRUE;
     switch ( memstate ) {
 	case MemUnknown:
 	    break;
 	case MemLow:
 	    memstate = MemUnknown;
 	    if ( !recoverMemory() ) {
 		QMessageBox::warning( 0 , tr("Memory Status"),
 		    tr("Memory Low\nPlease save data.") );
 		ignoreNormal = FALSE;
 	    }
 	    break;
 	case MemNormal:
 	    memstate = MemUnknown;
 	    if ( !ignoreNormal ) {
 		ignoreNormal = TRUE;
 		QMessageBox::information ( 0 , tr("Memory Status"),
 		    "Memory OK" );
 	    }
 	    break;
 	case MemVeryLow:
 	    memstate = MemUnknown;
 	    QMessageBox::critical( 0 , tr("Memory Status"),
 		tr("Critical Memory Shortage\n"
 		"Please end this application\n"
 		"immediately.") );
 	    recoverMemory();
     }
     existingMessage = FALSE;
 #endif
 }
 
 bool ServerApplication::recoverMemory()
 {
     return FALSE;
 }
 
 void ServerApplication::keyClick(int , bool press, bool )
 {
     if ( press && m_keyclick_sound )
         ODevice::inst() -> playKeySound();
 
 }
 
 void ServerApplication::screenClick(bool press)
 {
     if ( press && m_screentap_sound )
         ODevice::inst() -> playTouchSound();
 }
 
 void ServerApplication::soundAlarm() {
     if ( me ()->m_alarm_sound )
         ODevice::inst()->playAlarmSound();
 }
 
 ServerApplication *ServerApplication::me ( )
 {
 	return static_cast<ServerApplication*>( qApp );
 }
 
+bool ServerApplication::isStarting()
+{
+    return ms_is_starting;
+}
+
+int ServerApplication::exec()
+{
+    ms_is_starting = true;
+    qDebug("Serverapp - exec");
+    return QPEApplication::exec();
+}
 
 #include "serverapp.moc"
diff --git a/core/launcher/serverapp.h b/core/launcher/serverapp.h
index fe3f24a..4d9f808 100644
--- a/core/launcher/serverapp.h
+++ b/core/launcher/serverapp.h
@@ -33,133 +33,137 @@
 class PowerStatus;
 class DesktopPowerAlerter;
 
 class OpieScreenSaver;
 namespace Opie {
     class ODeviceButton;
 }
 
 struct QCopKeyRegister {
     QCopKeyRegister();
     QCopKeyRegister( int k, const QCString&, const QCString& );
     int keyCode()const;
     QCString channel()const;
     QCString message()const;
     inline bool send();
 
 private:
     int m_keyCode;
     QCString m_channel, m_message;
 };
 
 typedef QMap<int, QCopKeyRegister> KeyRegisterList;
 
 class KeyFilter : public QObject {
     Q_OBJECT
 public:
     KeyFilter(QObject* parent);
     void registerKey( const QCopKeyRegister& );
     void unregisterKey( const QCopKeyRegister& );
     bool checkButtonAction( bool, int, int, int );
 
 
 
 protected:
     void timerEvent(QTimerEvent*);
 
 signals:
     void launch();
     void power();
     void backlight();
     void symbol();
     void numLockStateToggle();
     void capsLockStateToggle();
     void activate(const Opie::ODeviceButton*,bool);
 
 
 private:
     bool keyRegistered( int key );
     int held_tid;
     const Opie::ODeviceButton* heldButton;
     KeyRegisterList m_keys;
 };
 
 class ServerApplication : public QPEApplication
 {
     Q_OBJECT
 public:
     ServerApplication( int& argc, char **argv, Type t );
     ~ServerApplication();
 
     static bool doRestart;
     static bool allowRestart;
     static bool screenLocked();
     static void login(bool at_poweron);
+    
+    static bool isStarting();
 
     static void switchLCD ( bool on ); // only for togglePower in Desktop
     static void soundAlarm(); // only because QCop soundAlarm() is defined in QPE/TaskBar
 
     void restart();
+    int exec();
 
 signals:
     void menu();
     void home();
     void launch();
     void power();
     void backlight();
     void symbol();
     void numLockStateToggle();
     void capsLockStateToggle();
     void prepareForRestart();
     void activate(const Opie::ODeviceButton*,bool);
 
 public slots:
     virtual void systemMessage( const QCString& msg, const QByteArray& );
     virtual void launcherMessage( const QCString& msg, const QByteArray& );
     void rereadVolumes();
 
 protected:
     bool eventFilter( QObject*,  QEvent* );
 #ifdef Q_WS_QWS
     bool qwsEventFilter( QWSEvent * );
 #endif
     void shutdown();
     void checkMemory();
     bool recoverMemory();
     void keyClick(int keycode, bool press, bool repeat);
     void screenClick(bool press);
 
 protected slots:
     void shutdown(ShutdownImpl::Type);
     void apmTimeout();
     void showSafeMode();
     void clearSafeMode();
     void togglePower();
     void toggleLight();
 
 private:
     static ServerApplication *me ();
     void reloadPowerWarnSettings();
     KeyFilter *kf;
 
 
 private:
     DesktopPowerAlerter *pa;
     PowerStatus *m_ps,  *m_ps_last;
     OpieScreenSaver *m_screensaver;
     QTimer *m_apm_timer;
     QDateTime m_suspendTime;
     int m_powerVeryLow;
     int m_powerCritical;
     int m_currentPowerLevel;
 
     bool m_keyclick_sound  : 1;
     bool m_screentap_sound : 1;
     bool m_alarm_sound     : 1;
+    static bool ms_is_starting;
 
 
     friend class KeyFilter;
 };
 
 
 #endif // SERVERAPP_H