thanks go to the programming god to point some bool alg stuff to me .-)

1 files changed, 6 insertions, 6 deletions

diff --git a/core/launcher/desktop.cpp b/core/launcher/desktop.cpp
index c4c6050..986ae5d 100644
--- a/core/launcher/desktop.cpp
+++ b/core/launcher/desktop.cpp
@@ -74,293 +74,293 @@ public:
   }
   QString getChannel() const
   {
     return channel;
   }
   QString getMessage() const
   {
     return message;
   }
 
 private:
   int keyCode;
   QString channel, message;
 };
 
 typedef QValueList<QCopKeyRegister> KeyRegisterList;
 KeyRegisterList keyRegisterList;
 
 static Desktop* qpedesktop = 0;
 static int loggedin = 0;
 static void login( bool at_poweron )
 {
   if ( !loggedin ) {
     Global::terminateBuiltin( "calibrate" );
     Password::authenticate( at_poweron );
     loggedin = 1;
     QCopEnvelope e( "QPE/Desktop", "unlocked()" );
   }
 }
 
 bool Desktop::screenLocked()
 {
   return loggedin == 0;
 }
 
 /*
   Priority is number of alerts that are needed to pop up
   alert.
  */
 class DesktopPowerAlerter : public QMessageBox
 {
 public:
   DesktopPowerAlerter( QWidget *parent, const char *name = 0 )
       : QMessageBox( tr( "Battery Status" ), "Low Battery",
                      QMessageBox::Critical,
                      QMessageBox::Ok | QMessageBox::Default,
                      QMessageBox::NoButton, QMessageBox::NoButton,
                      parent, name, FALSE )
   {
     currentPriority = INT_MAX;
     alertCount = 0;
   }
 
   void alert( const QString &text, int priority );
   void hideEvent( QHideEvent * );
 private:
   int currentPriority;
   int alertCount;
 };
 
 void DesktopPowerAlerter::alert( const QString &text, int priority )
 {
   alertCount++;
   if ( alertCount < priority )
     return ;
   if ( priority > currentPriority )
     return ;
   currentPriority = priority;
   setText( text );
   show();
 }
 
 
 void DesktopPowerAlerter::hideEvent( QHideEvent *e )
 {
   QMessageBox::hideEvent( e );
   alertCount = 0;
   currentPriority = INT_MAX;
 }
 
 class QPEScreenSaver : public QWSScreenSaver
 {
 private:
   int LcdOn;
 
 public:
   QPEScreenSaver()
   {
     m_disable_suspend = 100;
     m_enable_dim = false;
     m_enable_lightoff = false;
     m_enable_onlylcdoff = false;
 
     m_disable_suspend_ac = 100;
     m_enable_dim_ac = false;
     m_enable_lightoff_ac = false;
     m_enable_onlylcdoff_ac = false;
     m_disable_apm_ac = false;
 
     m_lcd_status = true;
 
     m_backlight_normal = -1;
     m_backlight_current = -1;
     m_backlight_forcedoff = false;
 
     // Make sure the LCD is in fact on, (if opie was killed while the LCD is off it would still be off)
     ODevice::inst ( )-> setDisplayStatus ( true );
     setBacklight ( -1 );
   }
   void restore()
   {
     if ( !m_lcd_status ) {    // We must have turned it off
       ODevice::inst ( ) -> setDisplayStatus ( true );
       m_lcd_status = true;
     }
 
     setBacklightInternal ( -1 );
   }
   bool save( int level )
   {
       bool onAC = ( PowerStatusManager::readStatus().acStatus() == PowerStatus::Online );
 
       switch ( level ) {
       case 0:
 
           if ( m_disable_suspend_ac > 0 && m_enable_dim_ac && onAC ) {
               if ( m_backlight_current > 1 )
                   setBacklight( 1 ); // lowest non-off
-          } else  if ( m_disable_suspend > 0 && m_enable_dim ) {
+          } else  if ( !onAC && m_disable_suspend > 0 && m_enable_dim ) {
               if ( m_backlight_current > 1 )
                   setBacklightInternal( 1 ); // lowest non-off
           }
           return true;
           break;
       case 1:
 
           if ( m_disable_suspend_ac > 1 && m_enable_lightoff_ac && onAC ) {
               setBacklightInternal( 0 ); // off
-          } else if ( m_disable_suspend > 1 && m_enable_lightoff ) {
+          } else if ( !onAC && m_disable_suspend > 1 && m_enable_lightoff ) {
               setBacklightInternal( 0 ); // off
           }
           return true;
           break;
       case 2:
           if ( m_disable_apm_ac && onAC ) {
               return true;
           }
 
           if ( m_enable_onlylcdoff_ac && onAC ) {
               ODevice::inst ( ) -> setDisplayStatus ( false );
               m_lcd_status = false;
               return true;
           }
-          else if ( m_enable_onlylcdoff ) {
+          else if ( !onAC && m_enable_onlylcdoff ) {
               ODevice::inst ( ) -> setDisplayStatus ( false );
               m_lcd_status = false;
               return true;
           }
           else // We're going to suspend the whole machine
           {
               if ( ( m_disable_suspend_ac > 2 && onAC ) && ( !Network::networkOnline ( ) ) ) {
                   QWSServer::sendKeyEvent( 0xffff, Qt::Key_F34, FALSE, TRUE, FALSE );
                   return true;
               }
-              if ( ( m_disable_suspend > 2 ) && ( !Network::networkOnline ( ) ) ) {
+              if ( !onAC && ( m_disable_suspend > 2 ) && ( !Network::networkOnline ( ) ) ) {
                   QWSServer::sendKeyEvent( 0xffff, Qt::Key_F34, FALSE, TRUE, FALSE );
                   return true;
               }
           }
           break;
       }
       return false;
   }
 
 private:
   static int ssi( int interval, Config & config, const QString & enable, const QString & value, int def )
   {
     if ( !enable.isEmpty() && config.readNumEntry( enable, 0 ) == 0 )
       return 0;
 
     if ( interval < 0 ) {
       // Restore screen blanking and power saving state
       interval = config.readNumEntry( value, def );
     }
     return interval;
   }
 
 public:
   void setIntervals( int i1, int i2, int i3 )
   {
     Config config( "qpe" );
     config.setGroup( "Screensaver" );
 
     int v[ 4 ];
     i1 = ssi( i1, config, "Dim", "Interval_Dim", 30 );
     i2 = ssi( i2, config, "LightOff", "Interval_LightOff", 20 );
     i3 = ssi( i3, config, "", "Interval", 60 );
 
     //qDebug("screen saver intervals: %d %d %d", i1, i2, i3);
 
     v [ 0 ] = QMAX( 1000 * i1, 100 );
     v [ 1 ] = QMAX( 1000 * i2, 100 );
     v [ 2 ] = QMAX( 1000 * i3, 100 );
     v [ 3 ] = 0;
     m_enable_dim = ( ( i1 != 0 ) ? config. readNumEntry ( "Dim", 1 ) : false );
     m_enable_lightoff = ( ( i2 != 0 ) ? config. readNumEntry ( "LightOff", 1 ) : false );
     m_enable_onlylcdoff = config.readNumEntry ( "LcdOffOnly", 0 );
 
     if ( !i1 && !i2 && !i3 )
       QWSServer::setScreenSaverInterval( 0 );
     else
       QWSServer::setScreenSaverIntervals( v );
   }
 
     void setIntervalsAC( int i1, int i2, int i3 )
   {
     Config config( "qpe" );
     config.setGroup( "Screensaver" );
 
     int v[ 4 ];
     i1 = ssi( i1, config, "DimAC", "Interval_DimAC", 30 );
     i2 = ssi( i2, config, "LightOffAC", "Interval_LightOffAC", 20 );
     i3 = ssi( i3, config, "", "IntervalAC", 60 );
 
     //qDebug("screen saver intervals: %d %d %d", i1, i2, i3);
 
     v [ 0 ] = QMAX( 1000 * i1, 100 );
     v [ 1 ] = QMAX( 1000 * i2, 100 );
     v [ 2 ] = QMAX( 1000 * i3, 100 );
     v [ 3 ] = 0;
     m_enable_dim_ac = ( ( i1 != 0 ) ? config.readNumEntry ( "DimAC", 1 ) : false );
     m_enable_lightoff_ac = ( ( i2 != 0 ) ? config.readNumEntry ( "LightOffAC", 1 ) : false );
     m_enable_onlylcdoff_ac = config.readNumEntry ( "LcdOffOnlyAC", 0 );
     m_disable_apm_ac =  config.readNumEntry ( "NoApmAC", 0 );
 
     if ( !i1 && !i2 && !i3 )
       QWSServer::setScreenSaverInterval( 0 );
     else
       QWSServer::setScreenSaverIntervals( v );
   }
 
   void setInterval ( int interval )
   {
     setIntervals ( -1, -1, interval );
   }
 
   void setMode ( int mode )
   {
     if ( mode > m_disable_suspend )
       setInterval( -1 );
     m_disable_suspend = mode;
   }
 
   void setBacklight ( int bright )
   {
     // Read from config
     Config config ( "qpe" );
     config. setGroup ( "Screensaver" );
     m_backlight_normal = config. readNumEntry ( "Brightness", 255 );
 
 	setBacklightInternal ( bright );
   }
 
 private:
   void setBacklightInternal ( int bright )
   {
     if ( bright == -3 ) {
       // Forced on
       m_backlight_forcedoff = false;
       bright = -1;
     }
     if ( m_backlight_forcedoff && bright != -2 )
       return ;
     if ( bright == -2 ) {
       // Toggle between off and on
       bright = m_backlight_current ? 0 : -1;
       m_backlight_forcedoff = !bright;
     }
 	if ( bright == -1 )
 		bright = m_backlight_normal;
 
 	if ( bright != m_backlight_current ) {
       ODevice::inst ( )-> setDisplayBrightness ( bright );
       m_backlight_current = bright;
     }
   }
 
 public:
   void setDisplayState ( bool on )
   {
     if ( m_lcd_status != on ) {
       ODevice::inst ( ) -> setDisplayStatus ( on );
       m_lcd_status = on;
@@ -520,267 +520,267 @@ bool DesktopApplication::qwsEventFilter( QWSEvent *e )
     if ( !loggedin && ke->simpleData.keycode != Key_F34 )
       return TRUE;
     bool press = ke->simpleData.is_press;
     bool autoRepeat = ke->simpleData.is_auto_repeat;
 
     /*
       app that registers key/message to be sent back to the app, when it doesn't have focus,
       when user presses key, unless keyboard has been requested from app.
       will not send multiple repeats if user holds key
       i.e. one shot
      */
     if ( !keyRegisterList.isEmpty() &&  ke->simpleData.keycode !=0 && press) {
 //        qDebug("<<<<<<<<<<<<<keycode %d", ke->simpleData.keycode);
       KeyRegisterList::Iterator it;
       for ( it = keyRegisterList.begin(); it != keyRegisterList.end(); ++it ) {
         if ( ( *it ).getKeyCode() == ke->simpleData.keycode && !autoRepeat && !keyboardGrabbed() ) {
           if ( press )
             qDebug( "press" );
           else
             qDebug( "release" );
           QCopEnvelope( ( *it ).getChannel().utf8(), ( *it ).getMessage().utf8() );
         }
       }
     }
 
     if ( !keyboardGrabbed() ) {
       if ( ke->simpleData.keycode == Key_F9 ) {
         if ( press )
           emit datebook();
         return TRUE;
       }
       if ( ke->simpleData.keycode == Key_F10 ) {
         if ( !press && cardSendTimer ) {
           emit contacts();
           delete cardSendTimer;
         }
         else if ( press ) {
           cardSendTimer = new QTimer();
           cardSendTimer->start( 2000, TRUE );
           connect( cardSendTimer, SIGNAL( timeout() ), this, SLOT( sendCard() ) );
         }
         return TRUE;
       }
 
 //         if ( ke->simpleData.keycode == Key_F11 ) {
 //         if ( press ) emit menu();
 //         return TRUE;
 //         }
 
       if ( ke->simpleData.keycode == Key_F12 ) {
         while ( activePopupWidget() )
           activePopupWidget() ->close();
         if ( press )
           emit launch();
         return TRUE;
       }
       if ( ke->simpleData.keycode == Key_F13 ) {
         if ( press )
           emit email();
         return TRUE;
       }
     }
 
     if ( ke->simpleData.keycode == Key_F34 ) {
       if ( press )
         emit power();
       return TRUE;
     }
     // This was used for the iPAQ PowerButton
     // See main.cpp for new KeyboardFilter
     //
     //    if ( ke->simpleData.keycode == Key_SysReq ) {
     //      if ( press ) emit power();
     //      return TRUE;
     //    }
     if ( ke->simpleData.keycode == Key_F35 ) {
       if ( press )
         emit backlight();
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_F32 ) {
       if ( press )
         QCopEnvelope e( "QPE/Desktop", "startSync()" );
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_F31 && !ke->simpleData.modifiers ) {
       if ( press )
         emit symbol();
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_NumLock ) {
       if ( press )
         emit numLockStateToggle();
     }
     if ( ke->simpleData.keycode == Key_CapsLock ) {
       if ( press )
         emit capsLockStateToggle();
     }
     if ( ( press && !autoRepeat ) || ( !press && autoRepeat ) )
       qpedesktop->keyClick();
   }
   else {
     if ( e->type == QWSEvent::Mouse ) {
       QWSMouseEvent * me = ( QWSMouseEvent * ) e;
       static bool up = TRUE;
       if ( me->simpleData.state & LeftButton ) {
         if ( up ) {
           up = FALSE;
           qpedesktop->screenClick();
         }
       }
       else {
         up = TRUE;
       }
     }
   }
 
   return QPEApplication::qwsEventFilter( e );
 }
 #endif
 
 void DesktopApplication::psTimeout( int batRemaining )
 {
   *ps = PowerStatusManager::readStatus();
 
   // maybe now since its triggered by apm change there might be to few warnings
   // if ( ( ps->batteryStatus() == PowerStatus::VeryLow ) ) {
   if ( ( batRemaining == m_powerVeryLow ) ) {
-       pa->alert( tr( "Battery is running very low." ), 6 );
+       pa->alert( tr( "Battery is running very low." ), 2 );
   }
 
    // if ( ps->batteryStatus() == PowerStatus::Critical ) {
    if ( batRemaining == m_powerCritical ) {
        pa->alert( tr( "Battery level is critical!\n"
                       "Keep power off until power restored!" ), 1 );
   }
 
   if ( ps->backupBatteryStatus() == PowerStatus::VeryLow ) {
-    pa->alert( tr( "The Back-up battery is very low.\nPlease charge the back-up battery." ), 3 );
+    pa->alert( tr( "The Back-up battery is very low.\nPlease charge the back-up battery." ), 2 );
   }
 }
 
 void DesktopApplication::apmTimeout()
 {
     qpedesktop->checkMemory(); // in case no events are being generated
 
     *ps = PowerStatusManager::readStatus();
 
     if ( m_currentPowerLevel != ps->batteryPercentRemaining() ) {
         // not very nice, since psTimeout parses the again
         m_currentPowerLevel = ps->batteryPercentRemaining();
         psTimeout( m_currentPowerLevel );
     }
 }
 
 void DesktopApplication::sendCard()
 {
   delete cardSendTimer;
   cardSendTimer = 0;
   QString card = getenv( "HOME" );
   card += "/Applications/addressbook/businesscard.vcf";
 
   if ( QFile::exists( card ) ) {
     QCopEnvelope e( "QPE/Obex", "send(QString,QString,QString)" );
     QString mimetype = "text/x-vCard";
     e << tr( "business card" ) << card << mimetype;
   }
 }
 
 #if defined(QPE_HAVE_MEMALERTER)
 QPE_MEMALERTER_IMPL
 #endif
 
 //===========================================================================
 
 Desktop::Desktop() :
     QWidget( 0, 0, WStyle_Tool | WStyle_Customize ),
     qcopBridge( 0 ),
     transferServer( 0 ),
     packageSlave( 0 )
 {
   qpedesktop = this;
 
   //    bg = new Info( this );
   tb = new TaskBar;
 
   launcher = new Launcher( 0, 0, WStyle_Customize | QWidget::WGroupLeader );
 
   connect( launcher, SIGNAL( busy() ), tb, SLOT( startWait() ) );
   connect( launcher, SIGNAL( notBusy( const QString& ) ), tb, SLOT( stopWait( const QString& ) ) );
 
   int displayw = qApp->desktop() ->width();
   int displayh = qApp->desktop() ->height();
 
 
   QSize sz = tb->sizeHint();
 
   setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
   tb->setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
 
   tb->show();
   launcher->showMaximized();
   launcher->show();
   launcher->raise();
 #if defined(QPE_HAVE_MEMALERTER)
 
   initMemalerter();
 #endif
   // start services
   startTransferServer();
   ( void ) new IrServer( this );
   rereadVolumes();
 
   packageSlave = new PackageSlave( this );
   connect( qApp, SIGNAL( volumeChanged( bool ) ), this, SLOT( rereadVolumes() ) );
 
   qApp->installEventFilter( this );
 
   qApp-> setMainWidget ( launcher );
 }
 
 void Desktop::show()
 {
   login( TRUE );
   QWidget::show();
 }
 
 Desktop::~Desktop()
 {
   delete launcher;
   delete tb;
   delete qcopBridge;
   delete transferServer;
 }
 
 bool Desktop::recoverMemory()
 {
   return tb->recoverMemory();
 }
 
 void Desktop::checkMemory()
 {
 #if defined(QPE_HAVE_MEMALERTER)
   static bool ignoreNormal = FALSE;
   static bool existingMessage = FALSE;
 
   if ( existingMessage )
     return ; // don't show a second message while still on first
 
   existingMessage = TRUE;
   switch ( memstate ) {
     case Unknown:
       break;
     case Low:
       memstate = Unknown;
       if ( recoverMemory() )
         ignoreNormal = TRUE;
       else
         QMessageBox::warning( 0 , "Memory Status",
                               "The memory smacks of shortage. \n"
                               "Please save data. " );
       break;
     case Normal:
       memstate = Unknown;
       if ( ignoreNormal )
         ignoreNormal = FALSE;
 //       else