1 files changed, 7 insertions, 4 deletions

diff --git a/core/launcher/desktop.cpp b/core/launcher/desktop.cpp
index fbcce7c..86527f6 100644
--- a/core/launcher/desktop.cpp
+++ b/core/launcher/desktop.cpp
@@ -257,223 +257,228 @@ void DesktopApplication::systemMessage( const QCString & msg, const QByteArray &
                 int t1, t2, t3;
                 stream >> t1 >> t2 >> t3;
                 m_screensaver-> setIntervals( t1, t2, t3 );
         }
         else if ( msg == "setBacklight(int)" ) {
                 int bright;
                 stream >> bright;
                 m_screensaver-> setBacklight( bright );
         }
         else if ( msg == "setScreenSaverMode(int)" ) {
                 int mode;
                 stream >> mode;
                 m_screensaver-> setMode ( mode );
         }
         else if ( msg == "reloadPowerWarnSettings()" ) {
                 reloadPowerWarnSettings();
         }
         else if ( msg == "setDisplayState(int)" ) {
                 int state;
                 stream >> state;
                 m_screensaver-> setDisplayState ( state != 0 );
         }
         else if ( msg == "suspend()" ) {
                 emit power();
         }
         else if ( msg == "sendBusinessCard()" ) {
                 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;
                 }
         }
 }
 
 void DesktopApplication::reloadPowerWarnSettings ( )
 {
         Config cfg ( "apm" );
         cfg. setGroup ( "Warnings" );
 
         int iv = cfg. readNumEntry ( "checkinterval", 10000 );
 
                 m_apm_timer-> stop ( );
         if ( iv )
                 m_apm_timer-> start ( iv );
                 
         m_powerVeryLow  = cfg. readNumEntry ( "powerverylow", 10 );
         m_powerCritical = cfg. readNumEntry ( "powervcritical", 5 );
 }
 
 
 enum MemState { Unknown, VeryLow, Low, Normal } memstate = Unknown;
 
 
 void DesktopApplication::launcherMessage( const QCString & msg, const QByteArray & data )
 {
         QDataStream stream ( data, IO_ReadOnly );
 
         if ( msg == "deviceButton(int,int,int)" ) {
                 int keycode, press, autoRepeat;
                 stream >> keycode >> press >> autoRepeat;
                 
                 const ODeviceButton *db = ODevice::inst ( )-> buttonForKeycode ( keycode );
                 
                 if ( db )
                     checkButtonAction ( db, keycode, press, autoRepeat );
         }
         else if ( msg == "keyRegister(int,QCString,QCString)" ) {
                 int k;
                 QCString c, m;
                 stream >> k >> c >> m;
 
                 keyRegisterList.append ( QCopKeyRegister ( k, c, m ));
         }
 }
 
 void DesktopApplication::sendHeldAction ( )
 {
         if ( m_last_button ) {
                 m_last_button-> heldAction ( ). send ( );
                 m_last_button = 0;
         }
 }
 
 
 
 bool DesktopApplication::checkButtonAction ( const ODeviceButton *db, int /*keycode*/, bool press, bool autoRepeat )
         {       
         if ( db ) {
                 if ( !press && !autoRepeat && m_button_timer-> isActive ( )) {
                         m_button_timer-> stop ( );
                         
                         if (!db-> pressedAction ( ). channel ( ) .isEmpty())
                         {
+
                                 if ( db-> pressedAction ( ). channel ( )!="ignore") {
+
                                         db-> pressedAction ( ). send ( );
                                 }
-                                else return false;
+                                else 
+                                   return false;
                         }
                 }
                 else if ( press && !autoRepeat ) {
                         m_button_timer-> stop ( );
                         if (!db-> pressedAction ( ). channel ( ) .isEmpty())
                         {
                         
                                 if ( db-> heldAction ( ). channel ( )!="ignore") {
                                         m_last_button = db;
                                         m_button_timer-> start ( ODevice::inst ( )-> buttonHoldTime ( ), true );
                                 }
                                 else return false;
                         }
                 }
         }
         return true;
 }
 
 bool DesktopApplication::eventFilter ( QObject *o, QEvent *e )
 {
+
         if ( e-> type ( ) == QEvent::KeyPress || e-> type ( ) == QEvent::KeyRelease ) {
                 QKeyEvent *ke = (QKeyEvent *) e;
         
                 const ODeviceButton *db = ODevice::inst ( )-> buttonForKeycode ( ke-> key ( ));
         
                 if ( db ) {
-                        return checkButtonAction ( db, ke-> key ( ), e-> type ( ) == QEvent::KeyPress, ke-> isAutoRepeat ( ));
+                        if (checkButtonAction ( db, ke-> key ( ), e-> type ( ) == QEvent::KeyPress, ke-> isAutoRepeat ( )))
+                                        return true;    //checkButtonAction retrune false if events should be routed through
                 }
         }
         return QPEApplication::eventFilter ( o, e );
 }
 
 #ifdef Q_WS_QWS
 
 bool DesktopApplication::qwsEventFilter( QWSEvent *e )
 {
         qpedesktop->checkMemory();
 
         if ( e->type == QWSEvent::Key ) {
                 QWSKeyEvent * ke = (QWSKeyEvent *) e;
                 ushort keycode = ke-> simpleData. keycode;
 
                 if ( !loggedin && keycode != Key_F34 )
                         return true;
                         
                 bool press = ke-> simpleData. is_press;
                 bool autoRepeat = ke-> simpleData. is_auto_repeat;
 
                 if ( !keyboardGrabbed ( )) {
                         // 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 ( keycode != 0 && press && !autoRepeat ) {
                                 for ( KeyRegisterList::Iterator it = keyRegisterList.begin(); it != keyRegisterList.end(); ++it ) {
                                         if (( *it ). getKeyCode ( ) == keycode ) {
                                                 QCopEnvelope (( *it ). getChannel ( ), ( *it ). getMessage ( ));
                                                 return true;
                                         }
                                 }
                         }
                 }
 
                 if ( keycode == HardKey_Suspend ) {
                         if ( press )
                                 emit power ( );
                         return true;
                 }
                 else if ( keycode == HardKey_Backlight ) {
                         if ( press )
                                 emit backlight ( );
                         return true;
                 }
                 else if ( keycode == Key_F32 ) {
                         if ( press )
                                 QCopEnvelope e( "QPE/Desktop", "startSync()" );
                         return true;
                 }
                 else if ( keycode == Key_F31 && !ke-> simpleData. modifiers ) { // Symbol Key -> show Unicode IM
                         if ( press )
                                 emit symbol ( );
                         return true;
                 }
                 else if ( keycode == Key_NumLock ) {
                         if ( press )
                                 emit numLockStateToggle ( );
                 }
                 else if ( keycode == Key_CapsLock ) {
                         if ( press )
                                 emit capsLockStateToggle();
                 }
                 if (( press && !autoRepeat ) || ( !press && autoRepeat )) {
                         if ( m_keyclick_sound )
                                 ODevice::inst ( )-> keySound ( );
                 }
         }
         else if ( e-> type == QWSEvent::Mouse ) {
                 QWSMouseEvent * me = ( QWSMouseEvent * ) e;
                 static bool up = true;
 
                 if ( me-> simpleData. state & LeftButton ) {
                         if ( up ) {
                                 up = false;
                                 if ( m_screentap_sound )
                                         ODevice::inst ( ) -> touchSound ( );
                         }
                 }
                 else {
                         up = true;
                 }
         }
 
         return QPEApplication::qwsEventFilter ( e );
 }
 #endif
 
 
 
 #if defined(QPE_HAVE_MEMALERTER)
 QPE_MEMALERTER_IMPL
 #endif
 
@@ -572,194 +577,192 @@ void Desktop::checkMemory()
                         //         QMessageBox::information ( 0 , "Memory Status",
                         //                                    "There is enough memory again." );
                         break;
                 case VeryLow:
                         memstate = Unknown;
                         QMessageBox::critical( 0 , "Memory Status",
                                                "The memory is very low. \n"
                                                "Please end this application \n"
                                                "immediately." );
                         recoverMemory();
         }
         existingMessage = FALSE;
 #endif
 }
 
 static bool isVisibleWindow( int wid )
 {
 #ifdef QWS
         const QList<QWSWindow> &list = qwsServer->clientWindows();
         QWSWindow* w;
         for ( QListIterator<QWSWindow> it( list ); ( w = it.current() ); ++it ) {
                 if ( w->winId() == wid )
                         return !w->isFullyObscured();
         }
 #endif
         return FALSE;
 }
 
 static bool hasVisibleWindow( const QString& clientname )
 {
 #ifdef QWS
         const QList<QWSWindow> &list = qwsServer->clientWindows();
         QWSWindow* w;
         for ( QListIterator<QWSWindow> it( list ); ( w = it.current() ); ++it ) {
                 if ( w->client() ->identity() == clientname && !w->isFullyObscured() )
                         return TRUE;
         }
 #endif
         return FALSE;
 }
 
 
 void Desktop::executeOrModify( const QString& appLnkFile )
 {
         AppLnk lnk( MimeType::appsFolderName() + "/" + appLnkFile );
         if ( lnk.isValid() ) {
                 QCString app = lnk.exec().utf8();
                 Global::terminateBuiltin( "calibrate" );
                 if ( QCopChannel::isRegistered( "QPE/Application/" + app ) ) {
                         //  MRUList::addTask( &lnk );
                         if ( hasVisibleWindow( app ) )
                                 QCopChannel::send( "QPE/Application/" + app, "nextView()" );
                         else
                                 QCopChannel::send( "QPE/Application/" + app, "raise()" );
                 }
                 else {
                         lnk.execute();
                 }
         }
 }
 
 // autoStarts apps on resume and start
 void Desktop::execAutoStart()
 {
         QString appName;
         int delay;
         QDateTime now = QDateTime::currentDateTime();
         Config cfg( "autostart" );
         cfg.setGroup( "AutoStart" );
         appName = cfg.readEntry( "Apps", "" );
         delay = ( cfg.readEntry( "Delay", "0" ) ).toInt();
         // If the time between suspend and resume was longer then the
         // value saved as delay, start the app
         if ( suspendTime.secsTo( now ) >= ( delay * 60 ) && !appName.isEmpty() ) {
                 QCopEnvelope e( "QPE/System", "execute(QString)" );
                 e << QString( appName );
         }
 }
 
 #if defined(QPE_HAVE_TOGGLELIGHT)
 #include <qpe/config.h>
 
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <linux/ioctl.h>
 #include <time.h>
 #endif
 
 
 void Desktop::togglePower()
 {
         static bool excllock = false;
 
-        qDebug ( "togglePower (locked == %d)", excllock ? 1 : 0 );
-
         if ( excllock )
                 return ;
 
         excllock = true;
 
         bool wasloggedin = loggedin;
         loggedin = 0;
         suspendTime = QDateTime::currentDateTime();
 
 #ifdef QWS
 
         if ( Password::needToAuthenticate ( true ) && qt_screen ) {
                 // Should use a big black window instead.
                 // But this would not show up fast enough
                 QGfx *g = qt_screen-> screenGfx ( );
                 g-> fillRect ( 0, 0, qt_screen-> width ( ), qt_screen-> height ( ));
                 delete g;
         }
 #endif
 
         ODevice::inst ( )-> suspend ( );
 
         DesktopApplication::switchLCD ( true ); // force LCD on without slow qcop call
         QWSServer::screenSaverActivate ( false );
 
         {
                 QCopEnvelope( "QPE/Card", "mtabChanged()" ); // might have changed while asleep
         }
 
         if ( wasloggedin )
                 login ( true );
 
         execAutoStart();
         //qcopBridge->closeOpenConnections();
 
         excllock = false;
 }
 
 void Desktop::toggleLight()
 {
         QCopEnvelope e( "QPE/System", "setBacklight(int)" );
         e << -2; // toggle
 }
 
 void Desktop::toggleSymbolInput()
 {
         tb->toggleSymbolInput();
 }
 
 void Desktop::toggleNumLockState()
 {
         tb->toggleNumLockState();
 }
 
 void Desktop::toggleCapsLockState()
 {
         tb->toggleCapsLockState();
 }
 
 void Desktop::styleChange( QStyle &s )
 {
         QWidget::styleChange( s );
         int displayw = qApp->desktop() ->width();
         int displayh = qApp->desktop() ->height();
 
         QSize sz = tb->sizeHint();
 
         tb->setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
 }
 
 void DesktopApplication::shutdown()
 {
         if ( type() != GuiServer )
                 return ;
         ShutdownImpl *sd = new ShutdownImpl( 0, 0, WDestructiveClose );
         connect( sd, SIGNAL( shutdown( ShutdownImpl::Type ) ),
                  this, SLOT( shutdown( ShutdownImpl::Type ) ) );
         sd->showMaximized();
 }
 
 void DesktopApplication::shutdown( ShutdownImpl::Type t )
 {
         char *opt = 0;
 
         switch ( t ) {
                 case ShutdownImpl::ShutdownSystem:
                         opt = "-h";
                         // fall through
                 case ShutdownImpl::RebootSystem:
                         if ( opt == 0 )
                                 opt = "-r";
 
                         if ( execl( "/sbin/shutdown", "shutdown", opt, "now", ( void* ) 0) < 0 )
                                 perror("shutdown");
         //                      ::syslog ( LOG_ERR, "Erroring execing shutdown\n" );