-Kill stupid define which sets QWS_SIZE to 240x320

-Include built-in shutdown only if OPIE_NO_BUILTIN_SHUTDOWN is defined

2 files changed, 2 insertions, 2 deletions

diff --git a/core/launcher/main.cpp b/core/launcher/main.cpp
index ad40536..74965df 100644
--- a/core/launcher/main.cpp
+++ b/core/launcher/main.cpp
@@ -1,354 +1,354 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 #ifndef QTOPIA_INTERNAL_FILEOPERATIONS
 #define QTOPIA_INTERNAL_FILEOPERATIONS
 #endif
 #include "server.h"
 #include "serverapp.h"
 #include "taskbar.h"
 #include "stabmon.h"
 #include "launcher.h"
 #include "firstuse.h"
 #include "launcherglobal.h"
 
 #include <qtopia/qpeapplication.h>
 #include <qtopia/network.h>
 #include <qtopia/config.h>
 #include <qtopia/custom.h>
 #include <qtopia/global.h>
 
 #include <qfile.h>
 #include <qdir.h>
 #ifdef QWS
 #include <qwindowsystem_qws.h>
 #include <qtopia/qcopenvelope_qws.h>
 #endif
 #include <qtopia/alarmserver.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <signal.h>
 #ifndef Q_OS_WIN32
 #include <unistd.h>
 #else
 #include <process.h>
 #endif
 
 #include "calibrate.h"
 
 
 #ifdef QT_QWS_LOGIN
 #include "../login/qdmdialogimpl.h"
 #endif
 
 #ifdef Q_WS_QWS
 #include <qkeyboard_qws.h>
 #endif
 
 #include <qmessagebox.h>
 #include <opie/odevice.h>
 
 using namespace Opie;
 
 
 static void cleanup()
 {
     QDir dir( Opie::Global::tempDir(), "qcop-msg-*" );
 
     QStringList stale = dir.entryList();
     QStringList::Iterator it;
     for ( it = stale.begin(); it != stale.end(); ++it ) {
         dir.remove( *it );
     }
 }
 
 static void refreshTimeZoneConfig()
 {
     /* ### FIXME timezone handling */
 #if 0
    // We need to help WorldTime in setting up its configuration for
    //   the current translation
     // BEGIN no tr
     const char *defaultTz[] = {
         "America/New_York",
         "America/Los_Angeles",
         "Europe/Oslo",
         "Asia/Tokyo",
         "Asia/Hong_Kong",
         "Australia/Brisbane",
         0
     };
     // END no tr
 
     TimeZone curZone;
     QString zoneID;
     int zoneIndex;
     Config cfg = Config( "WorldTime" );
     cfg.setGroup( "TimeZones" );
     if (!cfg.hasKey( "Zone0" )){
         // We have no existing timezones use the defaults which are untranslated strings
         QString currTz = TimeZone::current().id();
         QStringList zoneDefaults;
         zoneDefaults.append( currTz );
         for ( int i = 0; defaultTz[i] && zoneDefaults.count() < 6; i++ ) {
             if ( defaultTz[i] != currTz )
                 zoneDefaults.append( defaultTz[i] );
         }
         zoneIndex = 0;
         for (QStringList::Iterator it = zoneDefaults.begin(); it != zoneDefaults.end() ; ++it){
             cfg.writeEntry( "Zone" + QString::number( zoneIndex ) , *it);
             zoneIndex++;
         }
     }
     // We have an existing list of timezones refresh the
     //  translations of TimeZone name
     zoneIndex = 0;
     while (cfg.hasKey( "Zone"+ QString::number( zoneIndex ))){
         zoneID = cfg.readEntry( "Zone" + QString::number( zoneIndex ));
         curZone = TimeZone( zoneID );
         if ( !curZone.isValid() ){
             qDebug( "initEnvironment() Invalid TimeZone %s", zoneID.latin1() );
             break;
         }
         cfg.writeEntry( "ZoneName" + QString::number( zoneIndex ), curZone.city() );
         zoneIndex++;
     }
 #endif
 }
 
 void initEnvironment()
 {
 #ifdef Q_OS_WIN32
     // Config file requires HOME dir which uses QDir which needs the winver
     qt_init_winver();
 #endif
     Config config("locale");
     config.setGroup( "Location" );
     QString tz = config.readEntry( "Timezone", getenv("TZ") ).stripWhiteSpace();
 
     // if not timezone set, pick New York
     if (tz.isNull() || tz.isEmpty())
         tz = "America/New_York";
 
     setenv( "TZ", tz, 1 );
     config.writeEntry( "Timezone", tz);
 
     config.setGroup( "Language" );
     QString lang = config.readEntry( "Language", getenv("LANG") ).stripWhiteSpace();
     if( lang.isNull() || lang.isEmpty())
         lang = "en_US";
 
     setenv( "LANG", lang, 1 );
     config.writeEntry("Language", lang);
     config.write();
 
-#if !defined(QT_QWS_CASSIOPEIA) && !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX)
+#if 0
      setenv( "QWS_SIZE", "240x320", 0 );
 #endif
 
 
 
      QString env(getenv("QWS_DISPLAY"));
      if (env.contains("Transformed")) {
          int rot;
          // transformed driver default rotation is controlled by the hardware.
          Config config("qpe");
          config.setGroup( "Rotation" );
          if ( ( rot = config.readNumEntry( "Rot", -1 ) ) == -1 )
              rot = ODevice::inst ( )-> rotation ( ) * 90;
 
          setenv("QWS_DISPLAY", QString("Transformed:Rot%1:0").arg(rot), 1);
          QPEApplication::defaultRotation ( ); /* to ensure deforient matches reality */
      }
 }
 
 static void initKeyboard()
 {
     Config config("qpe");
 
     config.setGroup( "Keyboard" );
 
     int ard = config.readNumEntry( "RepeatDelay" );
     int arp = config.readNumEntry( "RepeatPeriod" );
     if ( ard > 0 && arp > 0 )
         qwsSetKeyboardAutoRepeat( ard, arp );
 
     QString layout = config.readEntry( "Layout", "us101" );
     Server::setKeyboardLayout( layout );
 }
 
 static bool firstUse()
 {
     bool needFirstUse = FALSE;
     if ( QWSServer::mouseHandler() &&
          QWSServer::mouseHandler() ->inherits("QCalibratedMouseHandler") ) {
         if ( !QFile::exists( "/etc/pointercal" ) )
             needFirstUse = TRUE;
     }
 
     {
         Config config( "qpe" );
         config.setGroup( "Startup" );
         needFirstUse |= config.readBoolEntry( "FirstUse", TRUE );
     }
 
     if ( !needFirstUse )
         return FALSE;
 
     FirstUse *fu = new FirstUse();
     fu->exec();
     bool rs = fu->restartNeeded();
     delete fu;
     return rs;
 }
 
 int initApplication( int argc, char ** argv )
 {
     cleanup();
 
 
     initEnvironment();
 
     //Don't flicker at startup:
 #ifdef QWS
     QWSServer::setDesktopBackground( QImage() );
 #endif
     ServerApplication a( argc, argv, QApplication::GuiServer );
 
     refreshTimeZoneConfig();
 
     initKeyboard();
 
     // Don't use first use under Windows
     if ( firstUse() ) {
         a.restart();
         return 0;
     }
 
     ODevice::inst ( )-> setSoftSuspend ( true );
 
     {
         QCopEnvelope e("QPE/System", "setBacklight(int)" );
           e << -3; // Forced on
     }
 
     AlarmServer::initialize();
 
 
 
     Server *s = new Server();
 
     (void)new SysFileMonitor(s);
 #ifdef QWS
     Network::createServer(s);
 #endif
 
     s->show();
 
     /* THE ARM rtc has problem holdings the time on reset */
     if ( QDate::currentDate ( ). year ( ) < 2000 ) {
         if ( QMessageBox::information ( 0, ServerApplication::tr( "Information" ), ServerApplication::tr( "<p>The system date doesn't seem to be valid.\n(%1)</p><p>Do you want to correct the clock ?</p>" ). arg( TimeString::dateString ( QDate::currentDate ( ))), QMessageBox::Yes, QMessageBox::No ) == QMessageBox::Yes ) {
             QCopEnvelope e ( "QPE/Application/systemtime", "setDocument(QString)" );
             e << QString ( );
         }
     }
 
     int rv =  a.exec();
 
     qDebug("exiting...");
     delete s;
 
     ODevice::inst()->setSoftSuspend( false );
 
     return rv;
 }
 
 static const char *pidfile_path = "/var/run/opie.pid";
 
 void create_pidfile ( )
 {
         FILE *f;
 
         if (( f = ::fopen ( pidfile_path, "w" ))) {
                 ::fprintf ( f, "%d", getpid ( ));
                 ::fclose ( f );
         }
 }
 
 void remove_pidfile ( )
 {
         ::unlink ( pidfile_path );
 }
 
 void handle_sigterm ( int /* sig */ )
 {
         if ( qApp )
                 qApp-> quit ( );
 }
 
 #ifndef Q_OS_WIN32
 int main( int argc, char ** argv )
 {
 
     ::signal ( SIGCHLD, SIG_IGN );
 
     ::signal ( SIGTERM, handle_sigterm );
     ::signal ( SIGINT, handle_sigterm );
 
     ::setsid ( );
     ::setpgid ( 0, 0 );
 
     ::atexit ( remove_pidfile );
     create_pidfile ( );
 
     int retVal = initApplication( argc, argv );
 
     // Have we been asked to restart?
     if ( ServerApplication::doRestart ) {
         for ( int fd = 3; fd < 100; fd++ )
             close( fd );
 
         execl( (QPEApplication::qpeDir()+"bin/qpe").latin1(), "qpe", 0 );
     }
 
     // Kill them. Kill them all.
     ::kill ( 0, SIGTERM );
     ::sleep ( 1 );
     ::kill ( 0, SIGKILL );
 
     return retVal;
 }
 #else
 
 int main( int argc, char ** argv )
 {
     int retVal = initApplication( argc, argv );
 
     if ( DesktopApplication::doRestart ) {
         qDebug("Trying to restart");
         execl( (QPEApplication::qpeDir()+"bin\\qpe").latin1(), "qpe", 0 );
     }
 
     return retVal;
 }
 
 #endif
 
diff --git a/core/launcher/server.cpp b/core/launcher/server.cpp
index 450d8e5..4c62b78 100644
--- a/core/launcher/server.cpp
+++ b/core/launcher/server.cpp
@@ -1,497 +1,497 @@
 /**********************************************************************
 ** 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 "launcher.h"
 #include "startmenu.h"
 #include "transferserver.h"
 #include "qcopbridge.h"
 #include "irserver.h"
 #include "packageslave.h"
 #include "calibrate.h"
 #include "qrsync.h"
 #include "syncdialog.h"
 #include "launcher.h"
 #include "shutdownimpl.h"
 #include "applauncher.h"
 #if 0
 #include "suspendmonitor.h"
 #endif
 #include "documentlist.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 <qwindowsystem_qws.h>
 #include <qgfx_qws.h>
 #include <qtopia/global.h>
 #include <qtopia/custom.h>
 
 #include <opie/odevicebutton.h>
 #include <opie/odevice.h>
 
 #include <unistd.h>
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qtextstream.h>
 
 #include <stdlib.h>
 
 extern QRect qt_maxWindowRect;
 
 using namespace Opie;
 
 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(QPE_NEED_CALIBRATION)
                 { "calibrate",          calibrate,        1, 0 }, // No tr
 #endif
-#if !defined(QT_QWS_CASSIOPEIA)
+#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::ODeviceButton*,bool)),
             this,SLOT(activate(const Opie::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 Opie::ODeviceButton* button, bool held)
 {
     Global::terminateBuiltin("calibrate"); // No tr
     Opie::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;
         qDebug( "desktop.cpp systemMsg -> linkchanged( %s )", link.latin1() );
         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
         //qDebug("QPE/System sendSyncDate for %s: response %s", app.latin1(),
         //cfg.readEntry( app ).latin1() );
     } else if ( msg == "setSyncDate(QString,QString)" ) {
         QString app, date;
         stream >> app >> date;
         Config cfg( "qpe" );
         cfg.setGroup("SyncDate");
         cfg.writeEntry( app, date );
         //qDebug("setSyncDate(QString,QString) %s %s", app.latin1(), date.latin1());
     } 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);