Remove unused code and mark parameter as Q_UNUSED

3 files changed, 6 insertions, 26 deletions

diff --git a/core/launcher/launcherview.cpp b/core/launcher/launcherview.cpp
index 0d0f2cb..cd9c14b 100644
--- a/core/launcher/launcherview.cpp
+++ b/core/launcher/launcherview.cpp
@@ -192,512 +192,514 @@ public:
     void addItem(AppLnk* app, bool resort=TRUE);
     bool removeLink(const QString& linkfile);
 
     QStringList mimeTypes() const;
     QStringList categories() const;
 
     void clear()
     {
         mimes.clear();
         cats.clear();
         QIconView::clear();
         hidden.clear();
     }
 
     void addCatsAndMimes(AppLnk* app)
     {
                 // QStringList c = app->categories();
                 // for (QStringList::ConstIterator cit=c.begin(); cit!=c.end(); ++cit) {
                 //     cats.replace(*cit,(void*)1);
                 // }
         QString maj=app->type();
         int sl=maj.find('/');
         if (sl>=0) {
             QString k;
             k = maj.left(12) == "application/" ? maj : maj.left(sl);
             mimes.replace(k,(void*)1);
         }
     }
 
     void setBackgroundOrigin( QWidget::BackgroundOrigin ) {
     }
 
     void setBackgroundPixmap( const QPixmap &pm ) {
         bgPixmap = pm;
     }
 
     void setBackgroundColor( const QColor &c ) {
         bgColor = c;
     }
 
     void drawBackground( QPainter *p, const QRect &r )
     {
         if ( !bgPixmap.isNull() ) {
            p->drawTiledPixmap( r, bgPixmap,
                    QPoint( (r.x() + contentsX()) % bgPixmap.width(),
                            (r.y() + contentsY()) % bgPixmap.height() ) );
         } else {
             p->fillRect( r, bgColor );
         }
     }
 
     void setItemTextPos( ItemTextPos pos )
     {
         calculateGrid( pos );
         QIconView::setItemTextPos( pos );
     }
 
     void hideOrShowItems(bool resort);
 
     void setTypeFilter(const QString& typefilter, bool resort)
     {
         tf = QRegExp(typefilter,FALSE,TRUE);
         hideOrShowItems(resort);
     }
 
     void setCategoryFilter( int catfilter, bool resort )
     {
         Categories cat;
         cat.load( categoryFileName() );
         QString str;
         if ( catfilter == -2 )
             cf = 0;
         else
             cf = catfilter;
         hideOrShowItems(resort);
     }
 
     enum SortMethod { Name, Date, Type };
 
     void setSortMethod( SortMethod m )
     {
         if ( sortmeth != m ) {
             sortmeth = m;
             sort();
         }
     }
 
     int compare(const AppLnk* a, const AppLnk* b)
     {
         switch (sortmeth) {
         case Name:
             return a->name().lower().compare(b->name().lower());
         case Date: {
             QFileInfo fa(a->linkFileKnown() ? a->linkFile() : a->file());
             QFileInfo fb(b->linkFileKnown() ? b->linkFile() : b->file());
             return fa.lastModified().secsTo(fb.lastModified());
         }
         case Type:
             return a->type().compare(b->type());
         }
         return 0;
     }
 
 protected:
 
     void timerEvent( QTimerEvent *te )
     {
         if ( te->timerId() == busyTimer ) {
             if ( bsy )
                 bsy->animateIcon();
         } else {
             QIconView::timerEvent( te );
         }
     }
 
     void styleChange( QStyle &old )
     {
         QIconView::styleChange( old );
         calculateGrid( itemTextPos() );
     }
 
     void calculateGrid( ItemTextPos pos )
     {
         int dw = QApplication::desktop()->width();
         int viewerWidth = dw-style().scrollBarExtent().width();
         if ( pos == Bottom ) {
             int cols = 3;
             if ( viewerWidth <= 200 )
                 cols = 2;
             else if ( viewerWidth >= 400 )
                  cols = viewerWidth/96;
             setSpacing( 4 );
             setGridX( (viewerWidth-(cols+1)*spacing())/cols );
             setGridY( fontMetrics().height()*2+24 );
         } else {
             int cols = 2;
             if ( viewerWidth < 150 )
                 cols = 1;
             else if ( viewerWidth >= 400 )
                  cols = viewerWidth/150;
             setSpacing( 2 );
             setGridX( (viewerWidth-(cols+1)*spacing())/cols );
             setGridY( fontMetrics().height()+2 );
         }
     }
 
     void focusInEvent( QFocusEvent * ) {}
     void focusOutEvent( QFocusEvent * ) {}
 
 private:
     QList<AppLnk> hidden;
     QDict<void> mimes;
     QDict<void> cats;
     SortMethod sortmeth;
     QRegExp tf;
     int cf;
     LauncherItem* bsy;
     int busyTimer;
     bool ike;
     bool bigIcns;
     QPixmap bgPixmap;
     QColor bgColor;
 #ifdef USE_ANIMATED_BUSY_ICON_OVERLAY
     QPixmap busyPix;
 #endif
   BusyIndicatorType busyType;
 };
 
 
 bool LauncherView::bsy=FALSE;
 
 void LauncherView::setBusy(bool on)
 {
     icons->setBusy(on);
 }
 
 void LauncherView::setBusyIndicatorType( const QString& type ) {
     if ( type. lower ( ) == "animated" )
         icons->setBusyIndicatorType(  BIT_Animated  ) ;
     else
         icons->setBusyIndicatorType(  BIT_Normal  ) ;
 }
 
 LauncherItem::LauncherItem( QIconView *parent, AppLnk *applnk, bool bigIcon )
     : QIconViewItem( parent, applnk->name(),
            bigIcon ? applnk->bigPixmap() :applnk->pixmap() ),
         isBigIcon( bigIcon ),
         iteration(0),
         app(applnk) // Takes ownership
 {
 }
 
 LauncherItem::~LauncherItem()
 {
     LauncherIconView* liv = (LauncherIconView*)iconView();
     if ( liv->busyItem() == this )
         liv->setBusy(FALSE);
     delete app;
 }
 
 int LauncherItem::compare ( QIconViewItem * i ) const
 {
     LauncherIconView* view = (LauncherIconView*)iconView();
     return view->compare(app,((LauncherItem *)i)->appLnk());
 }
 
 void LauncherItem::paintItem( QPainter *p, const QColorGroup &cg )
 {
     LauncherIconView* liv = (LauncherIconView*)iconView();
     QBrush oldBrush( liv->itemTextBackground() );
     QColorGroup mycg( cg );
     if ( liv->currentItem() == this ) {
         liv->setItemTextBackground( cg.brush( QColorGroup::Highlight ) );
         mycg.setColor( QColorGroup::Text, cg.color( QColorGroup::HighlightedText ) );
     }
 
     QIconViewItem::paintItem(p,mycg);
 
     // Paint animation overlay
     if ( liv->busyItem() == this )
         paintAnimatedIcon(p);
 
     if ( liv->currentItem() == this )
         liv->setItemTextBackground( oldBrush );
 }
 
 
 
 void LauncherItem::paintAnimatedIcon( QPainter *p )
 {
     LauncherIconView* liv = (LauncherIconView*)iconView();
     int pic = iteration % 16;
     int w = pixmap()->width(), h = pixmap()->height();
     QPixmap dblBuf( w, h + 4 );
     QPainter p2( &dblBuf );
     int x1, y1;
     if ( liv->itemTextPos() == QIconView::Bottom ) {
         x1 = x() + (width() - w) / 2 - liv->contentsX();
         y1 = y() - liv->contentsY();
     } else {
         x1 = x() - liv->contentsX();
         y1 = y() + (height() - h) / 2 - liv->contentsY();
     }
     y1 -= 2;
     p2.translate(-x1,-y1);
     liv->drawBackground( &p2, QRect(x1,y1,w,h+4) );
     int bounceY = 2;
 #ifdef BOUNCE_BUSY_ICON
     if ( busyType == BIT_Animated ) {
        bounceY = 4 - ((iteration+2)%8);
        bounceY = bounceY < 0 ? -bounceY : bounceY;
     }
 #endif
     p2.drawPixmap( x1, y1 + bounceY, *pixmap() );
 #ifdef USE_ANIMATED_BUSY_ICON_OVERLAY
     p2.drawPixmap( x1, y1 + bounceY, liv->busyPixmap(), w * pic, 0, w, h );
+#else
+    Q_UNUSED( pic )
 #endif
     p->drawPixmap( x1, y1, dblBuf );
 }
 
 void LauncherItem::animateIcon()
 {
     LauncherIconView* liv = (LauncherIconView*)iconView();
 
     if ( liv->busyItem() != this || !app )
         return;
 
     // Highlight the icon
     if ( iteration == 0 ) {
         QPixmap src = isBigIcon ? app->bigPixmap() : app->pixmap();
         QImage img = src.convertToImage();
         QRgb *rgb;
         int count;
         if ( img.depth() == 32 ) {
             rgb = (QRgb*)img.bits();
             count = img.bytesPerLine()/sizeof(QRgb)*img.height();
         } else {
             rgb = img.colorTable();
             count = img.numColors();
         }
         for ( int r = 0; r < count; r++, rgb++ ) {
 #if defined(BRIGHTEN_BUSY_ICON)
             QColor c(*rgb);
             int h, s, v;
             c.hsv(&h,&s,&v);
             c.setHsv(h,QMAX(s-24,0),QMIN(v+48,255));
             *rgb = qRgba(c.red(),c.green(),c.blue(),qAlpha(*rgb));
 #elif defined(ALPHA_FADE_BUSY_ICON)
             *rgb = qRgba(qRed(*rgb),qGreen(*rgb),qBlue(*rgb),qAlpha(*rgb)/2);
 #endif
         }
         src.convertFromImage( img );
         setPixmap( src );
     }
 
     iteration++;
 
     // Paint animation overlay
     QPainter p( liv->viewport() );
     paintAnimatedIcon( &p );
 }
 
 void LauncherItem::resetIcon()
 {
     iteration = 0;
     setPixmap( isBigIcon ? app->bigPixmap() : app->pixmap() );
 }
 
 //===========================================================================
 
 QStringList LauncherIconView::mimeTypes() const
 {
     QStringList r;
     QDictIterator<void> it(mimes);
     while (it.current()) {
         r.append(it.currentKey());
         ++it;
     }
     r.sort();
     return r;
 }
 
 void LauncherIconView::addItem(AppLnk* app, bool resort)
 {
     addCatsAndMimes(app);
 
     if ( (tf.isEmpty() || tf.match(app->type()) >= 0)
          && (cf == 0 || app->categories().contains(cf)
              || cf == -1 && app->categories().count() == 0 ) )
         (void) new LauncherItem( this, app, bigIcns );
     else
         hidden.append(app);
     if ( resort )
         sort();
 }
 
 void LauncherIconView::updateCategoriesAndMimeTypes()
 {
     mimes.clear();
     cats.clear();
     LauncherItem* item = (LauncherItem*)firstItem();
     while (item) {
         addCatsAndMimes(item->appLnk());
         item = (LauncherItem*)item->nextItem();
     }
     QListIterator<AppLnk> it(hidden);
     AppLnk* l;
     while ((l=it.current())) {
         addCatsAndMimes(l);
         ++it;
     }
 }
 
 void LauncherIconView::hideOrShowItems(bool resort)
 {
     viewport()->setUpdatesEnabled( FALSE );
     hidden.setAutoDelete(FALSE);
     QList<AppLnk> links=hidden;
     hidden.clear();
     hidden.setAutoDelete(TRUE);
     LauncherItem* item = (LauncherItem*)firstItem();
     while (item) {
         links.append(item->takeAppLnk());
         item = (LauncherItem*)item->nextItem();
     }
     clear();
     QListIterator<AppLnk> it(links);
     AppLnk* l;
     while ((l=it.current())) {
         addItem(l,FALSE);
         ++it;
     }
     if ( resort && !autoArrange() )
         sort();
     viewport()->setUpdatesEnabled( TRUE );
 }
 
 bool LauncherIconView::removeLink(const QString& linkfile)
 {
     LauncherItem* item = (LauncherItem*)firstItem();
     AppLnk* l;
     bool did = FALSE;
     DocLnk dl(linkfile);
     while (item) {
         l = item->appLnk();
         LauncherItem *nextItem = (LauncherItem *)item->nextItem();
         if (  l->linkFileKnown() && l->linkFile() == linkfile
                 || l->fileKnown() && (
                     l->file() == linkfile
                     || dl.isValid() && dl.file() == l->file() ) ) {
             delete item;
             did = TRUE;
         }
         item = nextItem;
     }
     QListIterator<AppLnk> it(hidden);
     while ((l=it.current())) {
         ++it;
         if ( l->linkFileKnown() && l->linkFile() == linkfile
                 || l->file() == linkfile
                 || dl.isValid() && dl.file() == l->file() ) {
             hidden.removeRef(l);
            did = TRUE;
         }
     }
     return did;
 }
 
 //===========================================================================
 
 LauncherView::LauncherView( QWidget* parent, const char* name, WFlags fl )
     : QVBox( parent, name, fl )
 {
     catmb = 0;
     icons = new LauncherIconView( this );
     setFocusProxy(icons);
     QPEApplication::setStylusOperation( icons->viewport(), QPEApplication::RightOnHold );
 
     icons->setItemsMovable( FALSE );
     icons->setAutoArrange( TRUE );
     icons->setSorting( TRUE );
     icons->setFrameStyle( QFrame::NoFrame );
     icons->setMargin( 0 );
     icons->setSelectionMode( QIconView::NoSelection );
     icons->setBackgroundMode( PaletteBase );
     icons->setResizeMode( QIconView::Fixed );
     vmode = (ViewMode)-1;
     setViewMode( Icon );
 
     connect( icons, SIGNAL(mouseButtonClicked(int,QIconViewItem*,const QPoint&)),
                    SLOT(itemClicked(int,QIconViewItem*)) );
     connect( icons, SIGNAL(selectionChanged()),
                    SLOT(selectionChanged()) );
     connect( icons, SIGNAL(returnPressed(QIconViewItem*)),
                    SLOT(returnPressed(QIconViewItem*)) );
     connect( icons, SIGNAL(mouseButtonPressed(int,QIconViewItem*,const QPoint&)),
                    SLOT(itemPressed(int,QIconViewItem*)) );
 
     tools = 0;
     setBackgroundType( Ruled, QString::null );
 }
 
 LauncherView::~LauncherView()
 {
     if ( bgCache && bgCache->contains( bgName ) )
         (*bgCache)[bgName]->ref--;
 }
 
 void LauncherView::hideIcons()
 {
     icons->hide();
 }
 
 void LauncherView::setToolsEnabled(bool y)
 {
     if ( !y != !tools ) {
         if ( y ) {
             tools = new QHBox(this);
 
             // Type filter
             typemb = new QComboBox(tools);
             QSizePolicy p = typemb->sizePolicy();
             p.setHorData(QSizePolicy::Expanding);
             typemb->setSizePolicy(p);
 
             // Category filter
             updateTools();
             tools->show();
 
         } else {
             delete tools;
             tools = 0;
         }
     }
 }
 
 void LauncherView::updateTools()
 {
     disconnect( typemb, SIGNAL(activated(int)),
                 this, SLOT(showType(int)) );
     if ( catmb ) disconnect( catmb, SIGNAL(signalSelected(int)),
                 this, SLOT(showCategory(int)) );
 
     // ### I want to remove this
     icons->updateCategoriesAndMimeTypes();
 
     QString prev;
 
     // Type filter
     QStringList types;
     typelist = icons->mimeTypes();
     for (QStringList::ConstIterator it = typelist.begin(); it!=typelist.end(); ++it) {
         QString t = *it;
         if ( t.left(12) == "application/" ) {
             MimeType mt(t);
             const AppLnk* app = mt.application();
             if ( app )
                 t = app->name();
             else
                 t = t.mid(12);
         } else {
             t[0] = t[0].upper();
         }
         types += t;
     }
     types << tr("All types");
     prev = typemb->currentText();
     typemb->clear();
     typemb->insertStringList(types);
     for (int i=0; i<typemb->count(); i++) {
         if ( typemb->text(i) == prev ) {
             typemb->setCurrentItem(i);
diff --git a/core/launcher/server.cpp b/core/launcher/server.cpp
index 950032d..5ae517b 100644
--- a/core/launcher/server.cpp
+++ b/core/launcher/server.cpp
@@ -1,729 +1,707 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 #include "server.h"
 #include "serverapp.h"
 #include "startmenu.h"
 #include "launcher.h"
 #include "transferserver.h"
 #include "qcopbridge.h"
 #include "irserver.h"
 #include "packageslave.h"
 #include "calibrate.h"
 #include "qrsync.h"
 #include "syncdialog.h"
 #include "shutdownimpl.h"
 #include "applauncher.h"
 #if 0
 #include "suspendmonitor.h"
 #endif
 #include "documentlist.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <opie2/odevicebutton.h>
 #include <opie2/odevice.h>
 #include <qtopia/applnk.h>
 #include <qtopia/private/categories.h>
 #include <qtopia/mimetype.h>
 #include <qtopia/config.h>
 #include <qtopia/resource.h>
 #include <qtopia/version.h>
 #include <qtopia/storage.h>
 #include <qtopia/qcopenvelope_qws.h>
 #include <qtopia/global.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qtextstream.h>
 #include <qwindowsystem_qws.h>
 #include <qgfx_qws.h>
 
 /* STD */
 #include <unistd.h>
 #include <stdlib.h>
 
 extern QRect qt_maxWindowRect;
 
 static QWidget *calibrate(bool)
 {
 #ifdef Q_WS_QWS
     Calibrate *c = new Calibrate;
     c->show();
     return c;
 #else
     return 0;
 #endif
 }
 
 #define FACTORY(T) \
     static QWidget *new##T( bool maximized ) { \
     QWidget *w = new T( 0, 0, QWidget::WDestructiveClose | QWidget::WGroupLeader ); \
     if ( maximized ) { \
         if ( qApp->desktop()->width() <= 350 ) { \
         w->showMaximized(); \
         } else { \
         w->resize( QSize( 300, 300 ) ); \
         } \
     } \
     w->show(); \
     return w; \
     }
 
 
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) FACTORY(b)
 #include "apps.h"
 #undef APP
 #endif // SINGLE_APP
 
 static Global::Command builtins[] = {
 
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) { a, new##b, c, d },
 #include "apps.h"
 #undef APP
 #endif
 
     /* FIXME defines need to be defined*/
 #if !defined(OPIE_NO_BUILTIN_CALIBRATE)
         { "calibrate",          calibrate,          1, 0 }, // No tr
 #endif
 #if !defined(OPIE_NO_BUILTIN_SHUTDOWN)
     { "shutdown",           Global::shutdown,       1, 0 }, // No tr
 //  { "run",                run,            1, 0 }, // No tr
 #endif
 
     { 0,            calibrate,  0, 0 },
 };
 
 
 //---------------------------------------------------------------------------
 
 
 //===========================================================================
 
 Server::Server() :
     QWidget( 0, 0, WStyle_Tool | WStyle_Customize ),
     qcopBridge( 0 ),
     transferServer( 0 ),
     packageHandler( 0 ),
     syncDialog( 0 )
 {
     Global::setBuiltinCommands(builtins);
 
     tid_xfer = 0;
     /* ### FIXME ### */
 /*    tid_today = startTimer(3600*2*1000);*/
     last_today_show = QDate::currentDate();
 
 #if 0
     tsmMonitor = new TempScreenSaverMode();
     connect( tsmMonitor, SIGNAL(forceSuspend()), qApp, SIGNAL(power()) );
 #endif
 
     serverGui = new Launcher;
     serverGui->createGUI();
 
     docList = new DocumentList( serverGui );
     appLauncher = new AppLauncher(this);
     connect(appLauncher, SIGNAL(launched(int,const QString&)), this, SLOT(applicationLaunched(int,const QString&)) );
     connect(appLauncher, SIGNAL(terminated(int,const QString&)), this, SLOT(applicationTerminated(int,const QString&)) );
     connect(appLauncher, SIGNAL(connected(const QString&)), this, SLOT(applicationConnected(const QString&)) );
 
     storage = new StorageInfo( this );
     connect( storage, SIGNAL(disksChanged()), this, SLOT(storageChanged()) );
 
     // start services
     startTransferServer();
     (void) new IrServer( this );
 
     packageHandler = new PackageHandler( this );
     connect(qApp, SIGNAL(activate(const Opie::Core::ODeviceButton*,bool)),
             this,SLOT(activate(const Opie::Core::ODeviceButton*,bool)));
 
     setGeometry( -10, -10, 9, 9 );
 
     QCopChannel *channel = new QCopChannel("QPE/System", this);
     connect(channel, SIGNAL(received(const QCString&,const QByteArray&)),
         this, SLOT(systemMsg(const QCString&,const QByteArray&)) );
 
     QCopChannel *tbChannel = new QCopChannel( "QPE/TaskBar", this );
     connect( tbChannel, SIGNAL(received(const QCString&,const QByteArray&)),
         this, SLOT(receiveTaskBar(const QCString&,const QByteArray&)) );
 
     connect( qApp, SIGNAL(prepareForRestart()), this, SLOT(terminateServers()) );
     connect( qApp, SIGNAL(timeChanged()), this, SLOT(pokeTimeMonitors()) );
 
     preloadApps();
 }
 
 void Server::show()
 {
     ServerApplication::login(TRUE);
     QWidget::show();
 }
 
 Server::~Server()
 {
     serverGui->destroyGUI();
     delete docList;
     delete qcopBridge;
     delete transferServer;
     delete serverGui;
 #if 0
     delete tsmMonitor;
 #endif
 }
 
-static bool hasVisibleWindow(const QString& clientname, bool partial)
-{
-#ifdef QWS
-    const QList<QWSWindow> &list = qwsServer->clientWindows();
-    QWSWindow* w;
-    for (QListIterator<QWSWindow> it(list); (w=it.current()); ++it) {
-    if ( w->client()->identity() == clientname ) {
-        if ( partial && !w->isFullyObscured() )
-        return TRUE;
-        if ( !partial && !w->isFullyObscured() && !w->isPartiallyObscured() ) {
-# if QT_VERSION < 0x030000
-        QRect mwr = qt_screen->mapToDevice(qt_maxWindowRect,
-            QSize(qt_screen->width(),qt_screen->height()) );
-# else
-        QRect mwr = qt_maxWindowRect;
-# endif
-        if ( mwr.contains(w->requested().boundingRect()) )
-            return TRUE;
-        }
-    }
-    }
-#endif
-    return FALSE;
-}
 
 void Server::activate(const ODeviceButton* button, bool held)
 {
     Global::terminateBuiltin("calibrate"); // No tr
     OQCopMessage om;
     if ( held ) {
     om = button->heldAction();
     } else {
     om = button->pressedAction();
     }
 
     if ( om.channel() != "ignore" )
         om.send();
 
     // A button with no action defined, will return a null ServiceRequest.  Don't attempt
     // to send/do anything with this as it will crash
     /* ### FIXME */
 #if 0
     if ( !sr.isNull() ) {
     QString app = sr.app();
     bool vis = hasVisibleWindow(app, app != "qpe");
     if ( sr.message() == "raise()" && vis ) {
         sr.setMessage("nextView()");
     } else {
         // "back door"
         sr << (int)vis;
     }
 
     sr.send();
     }
 #endif
 }
 
 
 #ifdef Q_WS_QWS
 
 
 typedef struct KeyOverride {
     ushort scan_code;
     QWSServer::KeyMap map;
 };
 
 
 static const KeyOverride jp109keys[] = {
    { 0x03, {   Qt::Key_2,      '2'     , 0x22     , 0xffff  } },
    { 0x07, {   Qt::Key_6,      '6'     , '&'     , 0xffff  } },
    { 0x08, {   Qt::Key_7,      '7'     , '\''     , 0xffff  } },
    { 0x09, {   Qt::Key_8,      '8'     , '('     , 0xffff  } },
    { 0x0a, {   Qt::Key_9,      '9'     , ')'     , 0xffff  } },
    { 0x0b, {   Qt::Key_0,      '0'     , 0xffff  , 0xffff  } },
    { 0x0c, {   Qt::Key_Minus,      '-'     , '='     , 0xffff  } },
    { 0x0d, {   Qt::Key_AsciiCircum,'^'     , '~'     , '^' - 64  } },
    { 0x1a, {   Qt::Key_At,     '@'     , '`'     , 0xffff  } },
    { 0x1b, {   Qt::Key_BraceLeft, '['     , '{'  , '[' - 64  } },
    { 0x27, {   Qt::Key_Semicolon,  ';'     , '+'     , 0xffff  } },
    { 0x28, {   Qt::Key_Colon,  ':'    ,  '*'     , 0xffff  } },
    { 0x29, {   Qt::Key_Zenkaku_Hankaku,  0xffff  , 0xffff     , 0xffff  } },
    { 0x2b, {   Qt::Key_BraceRight,  ']'    , '}'     , ']'-64  } },
    { 0x70, {   Qt::Key_Hiragana_Katakana,    0xffff  , 0xffff  , 0xffff  } },
    { 0x73, {   Qt::Key_Backslash,  '\\'    , '_'  ,    0xffff  } },
    { 0x79, {   Qt::Key_Henkan,     0xffff  , 0xffff  , 0xffff  } },
    { 0x7b, {   Qt::Key_Muhenkan,   0xffff  , 0xffff  , 0xffff  } },
    { 0x7d, {   Qt::Key_yen,        0x00a5  , '|'     , 0xffff  } },
    { 0x00, {   0,          0xffff  , 0xffff  , 0xffff  } }
 };
 
 bool Server::setKeyboardLayout( const QString &kb )
 {
     //quick demo version that can be extended
 
     QIntDict<QWSServer::KeyMap> *om = 0;
     if ( kb == "us101" ) { // No tr
     om = 0;
     } else if ( kb == "jp109" ) {
     om = new QIntDict<QWSServer::KeyMap>(37);
     const KeyOverride *k = jp109keys;
     while ( k->scan_code ) {
         om->insert( k->scan_code, &k->map );
         k++;
     }
     }
     QWSServer::setOverrideKeys( om );
 
     return TRUE;
 }
 
 #endif
 
 void Server::systemMsg(const QCString &msg, const QByteArray &data)
 {
     QDataStream stream( data, IO_ReadOnly );
 
     if ( msg == "securityChanged()" ) {
     if ( transferServer )
        transferServer->authorizeConnections();
     if ( qcopBridge )
         qcopBridge->authorizeConnections();
     }
     /* ### FIXME support TempScreenSaverMode */
 #if 0
     else if ( msg == "setTempScreenSaverMode(int,int)" ) {
     int mode, pid;
     stream >> mode >> pid;
     tsmMonitor->setTempMode(mode, pid);
     }
 #endif
     else if ( msg == "linkChanged(QString)" ) {
     QString link;
     stream >> link;
     odebug << "desktop.cpp systemMsg -> linkchanged( " << link << " )" << oendl;
     docList->linkChanged(link);
     } else if ( msg == "serviceChanged(QString)" ) {
     MimeType::updateApplications();
     } else if ( msg == "mkdir(QString)" ) {
     QString dir;
     stream >> dir;
     if ( !dir.isEmpty() )
         mkdir( dir );
     } else if ( msg == "rdiffGenSig(QString,QString)" ) {
     QString baseFile, sigFile;
     stream >> baseFile >> sigFile;
     QRsync::generateSignature( baseFile, sigFile );
     } else if ( msg == "rdiffGenDiff(QString,QString,QString)" ) {
     QString baseFile, sigFile, deltaFile;
     stream >> baseFile >> sigFile >> deltaFile;
     QRsync::generateDiff( baseFile, sigFile, deltaFile );
     } else if ( msg == "rdiffApplyPatch(QString,QString)" ) {
     QString baseFile, deltaFile;
     stream >> baseFile >> deltaFile;
     if ( !QFile::exists( baseFile ) ) {
         QFile f( baseFile );
         f.open( IO_WriteOnly );
         f.close();
     }
     QRsync::applyDiff( baseFile, deltaFile );
 #ifndef QT_NO_COP
     QCopEnvelope e( "QPE/Desktop", "patchApplied(QString)" );
     e << baseFile;
 #endif
     } else if ( msg == "rdiffCleanup()" ) {
     mkdir( "/tmp/rdiff" );
     QDir dir;
     dir.setPath( "/tmp/rdiff" );
     QStringList entries = dir.entryList();
     for ( QStringList::Iterator it = entries.begin(); it != entries.end(); ++it )
         dir.remove( *it );
     } else if ( msg == "sendHandshakeInfo()" ) {
     QString home = getenv( "HOME" );
 #ifndef QT_NO_COP
     QCopEnvelope e( "QPE/Desktop", "handshakeInfo(QString,bool)" );
     e << home;
     int locked = (int) ServerApplication::screenLocked();
     e << locked;
 #endif
 
     }
     /*
      * QtopiaDesktop relies on the major number
      * to start with 1. We're at 0.9
      * so wee need to fake at least 1.4 to be able
      * to sync with QtopiaDesktop1.6
      */
     else if ( msg == "sendVersionInfo()" ) {
     QCopEnvelope e( "QPE/Desktop", "versionInfo(QString,QString)" );
         /* ### FIXME Architecture ### */
     e << QString::fromLatin1("1.7") << "Uncustomized Device";
     } else if ( msg == "sendCardInfo()" ) {
 #ifndef QT_NO_COP
     QCopEnvelope e( "QPE/Desktop", "cardInfo(QString)" );
 #endif
     storage->update();
     const QList<FileSystem> &fs = storage->fileSystems();
     QListIterator<FileSystem> it ( fs );
     QString s;
     QString homeDir = getenv("HOME");
     QString homeFs, homeFsPath;
     for ( ; it.current(); ++it ) {
         int k4 = (*it)->blockSize()/256;
         if ( (*it)->isRemovable() ) {
         s += (*it)->name() + "=" + (*it)->path() + "/Documents " // No tr
              + QString::number( (*it)->availBlocks() * k4/4 )
              + "K " + (*it)->options() + ";";
         } else if ( homeDir.contains( (*it)->path() ) &&
               (*it)->path().length() > homeFsPath.length() ) {
         homeFsPath = (*it)->path();
         homeFs =
             (*it)->name() + "=" + homeDir + "/Documents " // No tr
             + QString::number( (*it)->availBlocks() * k4/4 )
             + "K " + (*it)->options() + ";";
         }
     }
     if ( !homeFs.isEmpty() )
         s += homeFs;
 
 #ifndef QT_NO_COP
     e << s;
 #endif
     } else if ( msg == "sendSyncDate(QString)" ) {
     QString app;
     stream >> app;
     Config cfg( "qpe" );
     cfg.setGroup("SyncDate");
 #ifndef QT_NO_COP
     QCopEnvelope e( "QPE/Desktop", "syncDate(QString,QString)" );
     e  << app  << cfg.readEntry( app );
 #endif
     //odebug << "QPE/System sendSyncDate for " << app.latin1() << ": response "
     //       << cfg.readEntry( app ).latin1() << oendl;
     } else if ( msg == "setSyncDate(QString,QString)" ) {
     QString app, date;
     stream >> app >> date;
     Config cfg( "qpe" );
     cfg.setGroup("SyncDate");
     cfg.writeEntry( app, date );
     //odebug << "setSyncDate(QString,QString) " << app << " " << date << "" << oendl;
     } else if ( msg == "startSync(QString)" ) {
     QString what;
     stream >> what;
     delete syncDialog;
     syncDialog = new SyncDialog( this, what );
     syncDialog->show();
     connect( syncDialog, SIGNAL(cancel()), SLOT(cancelSync()) );
     } else if ( msg == "stopSync()") {
     delete syncDialog;
     syncDialog = 0;
     } else if (msg == "restoreDone(QString)") {
     docList->restoreDone();
     } else if ( msg == "getAllDocLinks()" ) {
     docList->sendAllDocLinks();
     }
 #ifdef Q_WS_QWS
     else if ( msg == "setMouseProto(QString)" ) {
     QString mice;
     stream >> mice;
     setenv("QWS_MOUSE_PROTO",mice.latin1(),1);
     qwsServer->openMouse();
     } else if ( msg == "setKeyboard(QString)" ) {
     QString kb;
     stream >> kb;
     setenv("QWS_KEYBOARD",kb.latin1(),1);
     qwsServer->openKeyboard();
 
     } else if ( msg == "setKeyboardAutoRepeat(int,int)" ) {
     int delay, period;
     stream >> delay >> period;
     qwsSetKeyboardAutoRepeat( delay, period );
     Config cfg( "qpe" );
     cfg.setGroup("Keyboard");
     cfg.writeEntry( "RepeatDelay", delay );
     cfg.writeEntry( "RepeatPeriod", period );
     } else if ( msg == "setKeyboardLayout(QString)" ) {
     QString kb;
     stream >> kb;
     setKeyboardLayout( kb );
     Config cfg( "qpe" );
     cfg.setGroup("Keyboard");
     cfg.writeEntry( "Layout", kb );
     } else if ( msg == "autoStart(QString)" ) {
         QString appName;
         stream >> appName;
         Config cfg( "autostart" );
         cfg.setGroup( "AutoStart" );
         if ( appName.compare("clear") == 0){
             cfg.writeEntry("Apps", "");
         }
     } else if ( msg == "autoStart(QString,QString)" ) {
         QString modifier, appName;
         stream >> modifier >> appName;
         Config cfg( "autostart" );
         cfg.setGroup( "AutoStart" );
         if ( modifier.compare("add") == 0 ){
             // only add if appname is entered
            if (!appName.isEmpty()) {
                 cfg.writeEntry("Apps", appName);
             }
         } else if (modifier.compare("remove") == 0 ) {
             // need to change for multiple entries
             // actually remove is right now simular to clear, but in future there
             // should be multiple apps in autostart possible.
             QString checkName;
             checkName = cfg.readEntry("Apps", "");
             if (checkName == appName) {
                 cfg.writeEntry("Apps", "");
             }
         }
         // case the autostart feature should be delayed
     } else if ( msg == "autoStart(QString,QString,QString)") {
          QString modifier, appName, delay;
          stream >> modifier >> appName >> delay;
         Config cfg( "autostart" );
 
         cfg.setGroup( "AutoStart" );
         if ( modifier.compare("add") == 0 ){
             // only add it appname is entered
             if (!appName.isEmpty()) {
                 cfg.writeEntry("Apps", appName);
                 cfg.writeEntry("Delay", delay);
             }
         } else {
         }
     }
 #endif
 }
 
 void Server::receiveTaskBar(const QCString &msg, const QByteArray &data)
 {
     QDataStream stream( data, IO_ReadOnly );
 
     if ( msg == "reloadApps()" ) {
     docList->reloadAppLnks();
     } else if ( msg == "soundAlarm()" ) {
     ServerApplication::soundAlarm();
     }
     else if ( msg == "setLed(int,bool)" ) {
     int led, status;
     stream >> led >> status;
 
         QValueList <OLed> ll = ODevice::inst ( )-> ledList ( );
         if ( ll. count ( )) {
             OLed l = ll. contains ( Led_Mail ) ? Led_Mail : ll [0];
             bool canblink = ODevice::inst ( )-> ledStateList ( l ). contains ( Led_BlinkSlow );
 
             ODevice::inst ( )-> setLedState ( l, status ? ( canblink ? Led_BlinkSlow : Led_On ) : Led_Off );
         }
     }
 }
 
 void Server::cancelSync()
 {
 #ifndef QT_NO_COP
     QCopEnvelope e( "QPE/Desktop", "cancelSync()" );
 #endif
     delete syncDialog;
     syncDialog = 0;
 }
 
 bool Server::mkdir(const QString &localPath)
 {
     QDir fullDir(localPath);
     if (fullDir.exists())
     return true;
 
     // at this point the directory doesn't exist
     // go through the directory tree and start creating the direcotories
     // that don't exist; if we can't create the directories, return false
 
     QString dirSeps = "/";
     int dirIndex = localPath.find(dirSeps);
     QString checkedPath;
 
     // didn't find any seps; weird, use the cur dir instead
     if (dirIndex == -1) {
     //odebug << "No seperators found in path " << localPath << "" << oendl;
     checkedPath = QDir::currentDirPath();
     }
 
     while (checkedPath != localPath) {
     // no more seperators found, use the local path
     if (dirIndex == -1)
         checkedPath = localPath;
     else {
         // the next directory to check
         checkedPath = localPath.left(dirIndex) + "/";
         // advance the iterator; the next dir seperator
         dirIndex = localPath.find(dirSeps, dirIndex+1);
     }
 
     QDir checkDir(checkedPath);
     if (!checkDir.exists()) {
         //odebug << "mkdir making dir " << checkedPath << "" << oendl;
 
         if (!checkDir.mkdir(checkedPath)) {
         odebug << "Unable to make directory " << checkedPath << "" << oendl;
         return FALSE;
         }
     }
 
     }
     return TRUE;
 }
 
 void Server::styleChange( QStyle &s )
 {
     QWidget::styleChange( s );
 }
 
 void Server::startTransferServer()
 {
     if ( !qcopBridge ) {
     // start qcop bridge server
     qcopBridge = new QCopBridge( 4243 );
     if ( qcopBridge->ok() ) {
         // ... OK
         connect( qcopBridge, SIGNAL(connectionClosed(const QHostAddress&)),
             this, SLOT(syncConnectionClosed(const QHostAddress&)) );
     } else {
         delete qcopBridge;
         qcopBridge = 0;
     }
     }
     if ( !transferServer ) {
     // start transfer server
     transferServer = new TransferServer( 4242 );
     if ( transferServer->ok() ) {
         // ... OK
     } else {
         delete transferServer;
         transferServer = 0;
     }
     }
     if ( !transferServer || !qcopBridge )
     tid_xfer = startTimer( 2000 );
 }
 
 void Server::timerEvent( QTimerEvent *e )
 {
     if ( e->timerId() == tid_xfer ) {
     killTimer( tid_xfer );
     tid_xfer = 0;
     startTransferServer();
     }
     /* ### FIXME today startin */
 #if 0
     else if ( e->timerId() == tid_today ) {
     QDate today = QDate::currentDate();
     if ( today != last_today_show ) {
         last_today_show = today;
         Config cfg("today");
         cfg.setGroup("Start");
 #ifndef QPE_DEFAULT_TODAY_MODE
 #define QPE_DEFAULT_TODAY_MODE "Never"
 #endif
         if ( cfg.readEntry("Mode",QPE_DEFAULT_TODAY_MODE) == "Daily" ) {
         QCopEnvelope env(Service::channel("today"),"raise()");
         }
     }
     }
 #endif
 }
 
 void Server::terminateServers()
 {
     delete transferServer;
     delete qcopBridge;
     transferServer = 0;
     qcopBridge = 0;
 }
 
 void Server::syncConnectionClosed( const QHostAddress & )
 {
     odebug << "Lost sync connection" << oendl;
     delete syncDialog;
     syncDialog = 0;
 }
 
 void Server::pokeTimeMonitors()
 {
 #if 0
     // inform all TimeMonitors
     QStrList tms = Service::channels("TimeMonitor");
     for (const char* ch = tms.first(); ch; ch=tms.next()) {
     QString t = getenv("TZ");
     QCopEnvelope e(ch, "timeChange(QString)");
     e << t;
     }
 #endif
 }
 
 void Server::applicationLaunched(int, const QString &app)
 {
     serverGui->applicationStateChanged( app, ServerInterface::Launching );
 }
 
 void Server::applicationTerminated(int pid, const QString &app)
 {
     serverGui->applicationStateChanged( app, ServerInterface::Terminated );
 #if 0
     tsmMonitor->applicationTerminated( pid );
+#else
+    Q_UNUSED( pid )
 #endif
 }
 
 void Server::applicationConnected(const QString &app)
 {
     serverGui->applicationStateChanged( app, ServerInterface::Running );
 }
 
 void Server::storageChanged()
 {
     system( "opie-update-symlinks" );
     serverGui->storageChanged( storage->fileSystems() );
     docList->storageChanged();
 }
 
 
 
 void Server::preloadApps()
 {
     Config cfg("Launcher");
     cfg.setGroup("Preload");
     QStringList apps = cfg.readListEntry("Apps",',');
     for (QStringList::ConstIterator it=apps.begin(); it!=apps.end(); ++it) {
 #ifndef QT_NO_COP
     QCopEnvelope e("QPE/Application/"+(*it).local8Bit(), "enablePreload()");
 #endif
     }
 }
 
diff --git a/core/launcher/serverapp.cpp b/core/launcher/serverapp.cpp
index a2302d8..66cc788 100644
--- a/core/launcher/serverapp.cpp
+++ b/core/launcher/serverapp.cpp
@@ -104,514 +104,514 @@ class DesktopPowerAlerter : public QMessageBox
 public:
     DesktopPowerAlerter( QWidget *parent, const char *name = 0 )
     : QMessageBox( tr("Battery Status"), tr("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;
 }
 
 //---------------------------------------------------------------------------
 
 KeyFilter::KeyFilter(QObject* parent) : QObject(parent), held_tid(0), heldButton(0)
 {
     /* We don't do this cause it would interfere with ODevice */
 #if 0
     qwsServer->setKeyboardFilter(this);
 #endif
 }
 
 void KeyFilter::timerEvent(QTimerEvent* e)
 {
     if ( e->timerId() == held_tid ) {
     killTimer(held_tid);
     // button held
     if ( heldButton ) {
         emit activate(heldButton, TRUE);
         heldButton = 0;
     }
     held_tid = 0;
     }
 }
 
 void KeyFilter::registerKey( const QCopKeyRegister& key )
 {
     m_keys.insert( key.keyCode(), key );
 }
 
 void KeyFilter::unregisterKey( const QCopKeyRegister& key )
 {
     m_keys.remove( key.keyCode() );
 }
 
 bool KeyFilter::keyRegistered( int key )
 {
     /*
      * Check if we've a key registered
      */
     if ( !m_keys[key].send())
         return false;
     else
         return true;
 }
 
 bool KeyFilter::checkButtonAction(bool db, int keycode,  int press, int autoRepeat)
 {
     if ( !loggedin
         // Permitted keys
         && keycode != Key_F34 // power
         && keycode != Key_F30 // select
         && keycode != Key_Enter
         && keycode != Key_Return
         && keycode != Key_Space
         && keycode != Key_Left
         && keycode != Key_Right
         && keycode != Key_Up
         && keycode != Key_Down )
     return TRUE;
 
         /* check if it was registered */
     if (!db ) {
         if (keycode != 0 &&press && !autoRepeat && keyRegistered(keycode) )
             return true;
     } else {
 
         // First check to see if DeviceButtonManager knows something about this button:
         const ODeviceButton* button = ODevice::inst()->buttonForKeycode(keycode);
         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::Core::ODeviceButton*,bool)),
              this,SIGNAL(activate(const Opie::Core::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 ODeviceButton* but = ODevice::inst()->buttonForKeycode( -1 );
+    /* make sure the event filter is installed */  /* std::limits<short>::max() when you've stdc++ */
+    const ODeviceButton* but = ODevice::inst()->buttonForKeycode( SHRT_MAX );
     Q_CONST_UNUSED( but )
 }
 
 
 ServerApplication::~ServerApplication()
 {
     ungrabKeyboard();
 
     delete pa;
     delete m_ps;
     delete m_ps_last;
 }
 
 void ServerApplication::apmTimeout()
 {
     serverApp-> checkMemory( ); // in case no events are generated
     *m_ps_last = *m_ps;
     *m_ps = PowerStatusManager::readStatus();
 
     if ( m_ps->acStatus() != m_ps_last-> acStatus() )
         m_screensaver-> powerStatusChanged( *m_ps );
 
     if ( m_ps->acStatus() == PowerStatus::Online ) {
         return;
     }
 
     int bat = m_ps-> batteryPercentRemaining();
 
     if ( bat < m_ps_last-> batteryPercentRemaining() ) {
         if ( bat <= m_powerCritical ) {
         QMessageBox battlow(
         tr("WARNING"),
         tr("<p>The battery level is critical!"
             "<p>Keep power off until AC is restored"),
         QMessageBox::Warning,
         QMessageBox::Cancel, QMessageBox::NoButton, QMessageBox::NoButton,
         0, QString::null, TRUE, WStyle_StaysOnTop);
         battlow.setButtonText(QMessageBox::Cancel, tr("Ok"));
         battlow.exec();
         } else if ( bat <= m_powerVeryLow )
             pa->alert( tr( "The battery is running very low. "), 2 );
     }
 
     if ( m_ps-> backupBatteryStatus() == PowerStatus::VeryLow ) {
         QMessageBox battlow(
         tr("WARNING"),
         tr("<p>The Back-up battery is very low"
             "<p>Please charge the back-up battery"),
         QMessageBox::Warning,
         QMessageBox::Cancel, QMessageBox::NoButton, QMessageBox::NoButton,
         0, QString::null, TRUE, WStyle_StaysOnTop);
         battlow.setButtonText(QMessageBox::Cancel, tr("Ok"));
         battlow.exec();
     }
 }
 
 void ServerApplication::systemMessage( const QCString& msg,
                                        const QByteArray& data )
 {
     QDataStream stream ( data, IO_ReadOnly );
 
     if ( msg == "setScreenSaverInterval(int)" ) {
         int time;
         stream >> time;
         m_screensaver-> setInterval( time );
     }
     else if ( msg == "setScreenSaverIntervals(int,int,int)" ) {
         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 ServerApplication::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 );
 }
 
 void ServerApplication::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;
 
         kf->checkButtonAction ( true, keycode, press, autoRepeat );
     }
     else if ( msg == "keyRegister(int,QCString,QCString)" ) {
         int k;
         QCString c, m;
         stream >> k >> c >> m;
 
         kf -> registerKey( QCopKeyRegister(k, c, m) );
     }
 }
 
 
 bool ServerApplication::screenLocked()
 {
     return loggedin == 0;
 }
 
 void ServerApplication::login(bool at_poweron)
 {
     if ( !loggedin ) {
         Global::terminateBuiltin("calibrate"); // No tr
         Opie::Security::MultiauthPassword::authenticate(at_poweron);
         loggedin=1;
 #ifndef QT_NO_COP
         QCopEnvelope e( "QPE/Desktop", "unlocked()" );
 #endif
     }
 }
 
 #if defined(QPE_HAVE_TOGGLELIGHT)
 #include <qtopia/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
 
 namespace {
     void execAutoStart(const QDateTime& suspendTime ) {
         QString appName;
         int delay;
         QDateTime now = QDateTime::currentDateTime();
 
         Config cfg( "autostart" );
         cfg.setGroup( "AutoStart" );
         appName = cfg.readEntry( "Apps", "" );
         delay = cfg.readNumEntry( "Delay", 0  );
 
         // 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 );
         }
     }
 }
 
 
 void ServerApplication::togglePower()
 {
     static bool excllock = false;
 
     if ( excllock )
         return ;
 
     excllock = true;
 
     bool wasloggedin = loggedin;
     loggedin = 0;
     m_suspendTime = QDateTime::currentDateTime();
 
 #ifdef QWS
     if ( Opie::Security::MultiauthPassword::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 ( );
 
     ServerApplication::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(m_suspendTime);
     //qcopBridge->closeOpenConnections();
 
     excllock = false;
 }
 
 void ServerApplication::toggleLight()
 {
 #ifndef QT_NO_COP
     QCopEnvelope e("QPE/System", "setBacklight(int)");
     e << -2; // toggle
 #endif
 }
 
 
 /*
  * We still listen to key events but handle them in
  * a special class
  */
 
 bool ServerApplication::eventFilter( QObject *o, QEvent *e) {
     if ( e->type() != QEvent::KeyPress &&
          e->type() != QEvent::KeyRelease )
         return QPEApplication::eventFilter( o, e );
 
     QKeyEvent *ke = static_cast<QKeyEvent*>( e );
     if ( kf->checkButtonAction( true, ke->key(),
                                 e->type() == QEvent::KeyPress,
                                 ke-> isAutoRepeat() ))
         return true;
 
     return QPEApplication::eventFilter( o, e );