8 files changed, 32 insertions, 40 deletions

diff --git a/core/apps/calibrate/main.cpp b/core/apps/calibrate/main.cpp
index d1ad083..1c295eb 100644
--- a/core/apps/calibrate/main.cpp
+++ b/core/apps/calibrate/main.cpp
@@ -1,42 +1,46 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of 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 "calibrate.h"
 
 #include <qfile.h>
 #include <qpe/qpeapplication.h>
 
+#ifdef QWS
+#include <qwindowsystem_qws.h>
+#endif
+
 int main( int argc, char ** argv )
 {
     QPEApplication a( argc, argv );
     int retval = 0;
 
-#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
-    if ( !QFile::exists( "/etc/pointercal" ) ) {
+#ifdef QWS
+    if ( QWSServer::mouseHandler() ->inherits("QCalibratedMouseHandler") ) {
+#endif
         // Make sure calibration widget starts on top.
-        Calibrate *cal = new Calibrate;
-        a.setMainWidget(cal);
-        a.showMainWidget(cal);
-        retval = a.exec();
-        delete cal;
+        Calibrate cal;
+        a.setMainWidget(&cal);
+        a.showMainWidget(&cal);
+        return a.exec();
+#ifdef QWS
     }
 #endif
-    return retval;
 }
diff --git a/core/apps/calibrate/opie-calibrate.control b/core/apps/calibrate/opie-calibrate.control
new file mode 100644
index 0000000..6eafb94
--- a/dev/null
+++ b/core/apps/calibrate/opie-calibrate.control
@@ -0,0 +1,8 @@
+Files: bin/calibrate apps/Settings/Calibrate.desktop
+Priority: required
+Section: opie/system
+Maintainer: Project Opie <opie@handhelds.org>
+Architecture: arm
+Version: $QPE_VERSION-$SUB_VERSION.3
+Depends: libqpe1, libqt2-emb
+Description: Opie calibration tool
diff --git a/core/launcher/desktop.cpp b/core/launcher/desktop.cpp
index 6def126..ef0bf4c 100644
--- a/core/launcher/desktop.cpp
+++ b/core/launcher/desktop.cpp
@@ -1,878 +1,876 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of 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 <syslog.h>
 
 #include "desktop.h"
 #include "info.h"
 #include "launcher.h"
 #include "qcopbridge.h"
 #include "shutdownimpl.h"
 #include "startmenu.h"
 #include "taskbar.h"
 #include "transferserver.h"
 #include "irserver.h"
 #include "packageslave.h"
 #include "screensaver.h"
 
 #include <qpe/applnk.h>
 #include <qpe/mimetype.h>
 #include <qpe/password.h>
 #include <qpe/config.h>
 #include <qpe/power.h>
 #include <qpe/timeconversion.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/network.h>
 #include <qpe/global.h>
 
 #if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
 #include <qpe/custom.h>
 #endif
 
 #include <opie/odevice.h>
 
 #include <qgfx_qws.h>
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qwindowsystem_qws.h>
 
 #include <qvaluelist.h>
 
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 
 
 using namespace Opie;
 
 class QCopKeyRegister
 {
 public:
         QCopKeyRegister() : keyCode( 0 )
         { }
         QCopKeyRegister( int k, const QCString &c, const QCString &m )
                         : keyCode( k ), channel( c ), message( m )
         { }
 
         int getKeyCode() const
         {
                 return keyCode;
         }
         QCString getChannel() const
         {
                 return channel;
         }
         QCString getMessage() const
         {
                 return message;
         }
 
 private:
         int keyCode;
         QCString channel, message;
 };
 
 typedef QValueList<QCopKeyRegister> KeyRegisterList;
 KeyRegisterList keyRegisterList;
 
 static Desktop* qpedesktop = 0;
 static int loggedin = 0;
 static void login( bool at_poweron )
 {
         if ( !loggedin ) {
-                Global::terminateBuiltin( "calibrate" );
                 Password::authenticate( at_poweron );
                 loggedin = 1;
                 QCopEnvelope e( "QPE/Desktop", "unlocked()" );
         }
 }
 
 bool Desktop::screenLocked()
 {
         return loggedin == 0;
 }
 
 /*
   Priority is number of alerts that are needed to pop up
   alert.
  */
 class DesktopPowerAlerter : public QMessageBox
 {
 public:
         DesktopPowerAlerter( QWidget *parent, const char *name = 0 )
                         : QMessageBox( tr( "Battery Status" ), "Low Battery",
                                        QMessageBox::Critical,
                                        QMessageBox::Ok | QMessageBox::Default,
                                        QMessageBox::NoButton, QMessageBox::NoButton,
                                        parent, name, FALSE )
         {
                 currentPriority = INT_MAX;
                 alertCount = 0;
         }
 
         void alert( const QString &text, int priority );
         void hideEvent( QHideEvent * );
 private:
         int currentPriority;
         int alertCount;
 };
 
 void DesktopPowerAlerter::alert( const QString &text, int priority )
 {
         alertCount++;
         if ( alertCount < priority )
                 return ;
         if ( priority > currentPriority )
                 return ;
         currentPriority = priority;
         setText( text );
         show();
 }
 
 
 void DesktopPowerAlerter::hideEvent( QHideEvent *e )
 {
         QMessageBox::hideEvent( e );
         alertCount = 0;
         currentPriority = INT_MAX;
 }
 
 
 void DesktopApplication::switchLCD ( bool on )
 {
         if ( qApp ) {
                 DesktopApplication *dapp = (DesktopApplication *) qApp;
 
                 if ( dapp-> m_screensaver ) {
                         if ( on ) {
                                 dapp-> m_screensaver-> setDisplayState ( true );
                                 dapp-> m_screensaver-> setBacklight ( -3 );
                         }
                         else {
                                 dapp-> m_screensaver-> setDisplayState ( false );
                         }
                 }
         }
 }
 
 
 DesktopApplication::DesktopApplication( int& argc, char **argv, Type appType )
                 : QPEApplication( argc, argv, appType )
 {
         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 ( );
 
         m_last_button = 0;
         m_button_timer = new QTimer ( );
         connect ( m_button_timer, SIGNAL( timeout ( )), this, SLOT( sendHeldAction ( )));
         
         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 );
 
         rereadVolumes();
         connect( qApp, SIGNAL( volumeChanged( bool ) ), this, SLOT( rereadVolumes() ) );
         
         apmTimeout ( );
         
         grabKeyboard ( );
 }
 
 
 DesktopApplication::~DesktopApplication()
 {
         ungrabKeyboard ( );
 
         delete m_ps;
         delete m_ps_last;
         delete pa;
 }
 
 void DesktopApplication::apmTimeout()
 {
         qpedesktop-> checkMemory ( ); // in case no events are being 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 ) {
                 int bat = m_ps-> batteryPercentRemaining ( );
 
                 if ( bat < m_ps_last-> batteryPercentRemaining ( )) {
                         if ( bat <= m_powerCritical )
                                 pa->alert( tr( "Battery level is critical!\nKeep power off until power restored!" ), 1 );
                         else if ( bat <= m_powerVeryLow )
                                 pa->alert( tr( "Battery is running very low." ), 2 );
                 }
                 if ( m_ps-> backupBatteryStatus ( ) == PowerStatus::VeryLow )
                         pa->alert( tr( "The Back-up battery is very low.\nPlease charge the back-up battery." ), 2 );
         }
 }
 
 
 void DesktopApplication::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 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 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 ) {
                         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
 
 //===========================================================================
 
 Desktop::Desktop() :
                 QWidget( 0, 0, WStyle_Tool | WStyle_Customize ),
                 qcopBridge( 0 ),
                 transferServer( 0 ),
                 packageSlave( 0 )
 {
         qpedesktop = this;
 
         //    bg = new Info( this );
         tb = new TaskBar;
 
         launcher = new Launcher( 0, 0, WStyle_Customize | QWidget::WGroupLeader );
 
         connect( launcher, SIGNAL( busy() ), tb, SLOT( startWait() ) );
         connect( launcher, SIGNAL( notBusy( const QString& ) ), tb, SLOT( stopWait( const QString& ) ) );
 
         int displayw = qApp->desktop() ->width();
         int displayh = qApp->desktop() ->height();
 
 
         QSize sz = tb->sizeHint();
 
         setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
         layout();
 
         tb->show();
         launcher->showMaximized();
         launcher->show();
         launcher->raise();
 #if defined(QPE_HAVE_MEMALERTER)
 
         initMemalerter();
 #endif
         // start services
         startTransferServer();
         ( void ) new IrServer( this );
 
         packageSlave = new PackageSlave( this );
 
         qApp->installEventFilter( this );
         qApp->desktop()->installEventFilter( this );
 
         qApp-> setMainWidget ( launcher );
 }
 
 void Desktop::show()
 {
         login( TRUE );
         QWidget::show();
 }
 
 Desktop::~Desktop()
 {
         delete launcher;
         delete tb;
         delete qcopBridge;
         delete transferServer;
 }
 
 bool Desktop::recoverMemory()
 {
         return tb->recoverMemory();
 }
 
 void Desktop::checkMemory()
 {
 #if defined(QPE_HAVE_MEMALERTER)
         static bool ignoreNormal = FALSE;
         static bool existingMessage = FALSE;
 
         if ( existingMessage )
                 return ; // don't show a second message while still on first
 
         existingMessage = TRUE;
         switch ( memstate ) {
                 case Unknown:
                         break;
                 case Low:
                         memstate = Unknown;
                         if ( recoverMemory() )
                                 ignoreNormal = TRUE;
                         else
                                 QMessageBox::warning( 0 , "Memory Status",
                                                       "The memory smacks of shortage. \n"
                                                       "Please save data. " );
                         break;
                 case Normal:
                         memstate = Unknown;
                         if ( ignoreNormal )
                                 ignoreNormal = FALSE;
                         //       else
                         //         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;
 
         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 );
         layout();
 }
 
 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" );
 
                         break;
                 case ShutdownImpl::RestartDesktop:
                         restart();
                         break;
                 case ShutdownImpl::TerminateDesktop:
                         prepareForTermination( FALSE );
 
                         // This is a workaround for a Qt bug
                         // clipboard applet has to stop its poll timer, or Qt/E
                         // will hang on quit() right before it emits aboutToQuit()
                         emit aboutToQuit ( );
 
                         quit();
                         break;
         }
 }
 
 void DesktopApplication::restart()
 {
         prepareForTermination( TRUE );
 
 #ifdef Q_WS_QWS
 
         for ( int fd = 3; fd < 100; fd++ )
                 close( fd );
 #if defined(QT_DEMO_SINGLE_FLOPPY)
 
         execl( "/sbin/init", "qpe", 0 );
 #elif defined(QT_QWS_CASSIOPEIA)
 
         execl( "/bin/sh", "sh", 0 );
 #else
 
         execl( ( qpeDir() + "/bin/qpe" ).latin1(), "qpe", 0 );
 #endif
 
         exit( 1 );
 #endif
 }
 
 void Desktop::layout()
 {
         int displayw = qApp->desktop() ->width();
         int displayh = qApp->desktop() ->height();
 
         QSize sz = tb->sizeHint();
 
         tb->setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
         tb->calcMaxWindowRect();
 }
 
 void Desktop::startTransferServer()
 {
         // start qcop bridge server
         qcopBridge = new QCopBridge( 4243 );
         if ( !qcopBridge->ok() ) {
                 delete qcopBridge;
                 qcopBridge = 0;
         }
         // start transfer server
         transferServer = new TransferServer( 4242 );
         if ( !transferServer->ok() ) {
                 delete transferServer;
                 transferServer = 0;
         }
         if ( !transferServer || !qcopBridge )
                 startTimer( 2000 );
 }
 
 void Desktop::timerEvent( QTimerEvent *e )
 {
         killTimer( e->timerId() );
         startTransferServer();
 }
 
 bool Desktop::eventFilter( QObject *o, QEvent *ev )
 {
     if ( o != qApp->desktop() || ev->type() != QEvent::Resize )
         return QWidget::eventFilter( o, ev );
 
     layout();
 
     return QWidget::eventFilter( o, ev );
 }
 
 void Desktop::terminateServers()
 {
         delete transferServer;
         delete qcopBridge;
         transferServer = 0;
         qcopBridge = 0;
 }
 
 void DesktopApplication::rereadVolumes()
 {
         Config cfg( "qpe" );
         cfg. setGroup ( "Volume" );
         
         m_screentap_sound = cfg. readBoolEntry ( "TouchSound" );
         m_keyclick_sound  = cfg. readBoolEntry ( "KeySound" );
         m_alarm_sound     = cfg. readBoolEntry ( "AlarmSound" );
 }
 
 void DesktopApplication::soundAlarm()
 {
         if ( me ( )-> m_alarm_sound )
                 ODevice::inst ( )-> alarmSound ( );
 }
 
 DesktopApplication *DesktopApplication::me ( )
 {
         return (DesktopApplication *) qApp;
 }
 
diff --git a/core/launcher/launcher.pro b/core/launcher/launcher.pro
index d0a573b..007e48c 100644
--- a/core/launcher/launcher.pro
+++ b/core/launcher/launcher.pro
@@ -1,124 +1,120 @@
         TEMPLATE= app
         CONFIG  = qt warn_on release
         DESTDIR         = ../../bin
         HEADERS         = background.h \
                   desktop.h \
                   screensaver.h \
                   mediummountgui.h \
                   info.h \
                   appicons.h \
                   taskbar.h \
                   sidething.h \
                   runningappbar.h \
                   stabmon.h \
                   inputmethods.h \
                   systray.h \
                   wait.h \
                   shutdownimpl.h \
                   launcher.h \
                   launcherview.h \
-                  ../../core/apps/calibrate/calibrate.h \
                   startmenu.h \
                   transferserver.h \
                   qcopbridge.h \
                   packageslave.h \
                 irserver.h \
         ../../rsync/buf.h \
         ../../rsync/checksum.h \
         ../../rsync/command.h \
         ../../rsync/emit.h \
         ../../rsync/job.h \
         ../../rsync/netint.h \
         ../../rsync/protocol.h \
         ../../rsync/prototab.h \
         ../../rsync/rsync.h \
         ../../rsync/search.h \
         ../../rsync/stream.h \
         ../../rsync/sumset.h \
         ../../rsync/trace.h \
         ../../rsync/types.h \
         ../../rsync/util.h \
         ../../rsync/whole.h \
         ../../rsync/config_rsync.h \
         ../../rsync/qrsync.h \
                   quicklauncher.h 
         SOURCES         = background.cpp \
                   desktop.cpp \
                   screensaver.cpp \
                   mediummountgui.cpp \
                   info.cpp \
                   appicons.cpp \
                   taskbar.cpp \
                   sidething.cpp \
                    runningappbar.cpp \
                   stabmon.cpp \
                   inputmethods.cpp \
                   systray.cpp \
                   wait.cpp \
                   shutdownimpl.cpp \
                   launcher.cpp \
                   launcherview.cpp \
-                  ../../core/apps/calibrate/calibrate.cpp \
                   transferserver.cpp \
                   packageslave.cpp \
                 irserver.cpp \
                   qcopbridge.cpp \
                   startmenu.cpp \
                   main.cpp \
         ../../rsync/base64.c \
         ../../rsync/buf.c \
         ../../rsync/checksum.c \
         ../../rsync/command.c \
         ../../rsync/delta.c \
         ../../rsync/emit.c \
         ../../rsync/hex.c \
         ../../rsync/job.c \
         ../../rsync/mdfour.c \
         ../../rsync/mksum.c \
         ../../rsync/msg.c \
         ../../rsync/netint.c \
         ../../rsync/patch.c \
         ../../rsync/prototab.c \
         ../../rsync/readsums.c \
         ../../rsync/scoop.c \
         ../../rsync/search.c \
         ../../rsync/stats.c \
         ../../rsync/stream.c \
         ../../rsync/sumset.c \
         ../../rsync/trace.c \
         ../../rsync/tube.c \
         ../../rsync/util.c \
         ../../rsync/version.c \
         ../../rsync/whole.c \
         ../../rsync/qrsync.cpp
         INTERFACES= syncdialog.ui
 INCLUDEPATH += ../../include
         DEPENDPATH+= ../../include .
-INCLUDEPATH += ../../core/apps/calibrate
-        DEPENDPATH+= ../../core/apps/calibrate
 INCLUDEPATH += ../../rsync
         DEPENDPATH+= ../../rsync
         TARGET  = qpe
         LIBS    += -lqpe -lcrypt -lopie 
 
 TRANSLATIONS = ../../i18n/de/qpe.ts \
          ../../i18n/xx/qpe.ts \
          ../../i18n/en/qpe.ts \
          ../../i18n/es/qpe.ts \
          ../../i18n/fr/qpe.ts \
          ../../i18n/hu/qpe.ts \
          ../../i18n/ja/qpe.ts \
          ../../i18n/ko/qpe.ts \
          ../../i18n/no/qpe.ts \
          ../../i18n/pl/qpe.ts \
          ../../i18n/pt/qpe.ts \
          ../../i18n/pt_BR/qpe.ts \
          ../../i18n/sl/qpe.ts \
          ../../i18n/zh_CN/qpe.ts \
          ../../i18n/it/qpe.ts \
          ../../i18n/zh_TW/qpe.ts \
          ../../i18n/da/qpe.ts
 
 
 
 include ( $(OPIEDIR)/include.pro )
diff --git a/core/launcher/main.cpp b/core/launcher/main.cpp
index 20a1ecd..e96eeae 100644
--- a/core/launcher/main.cpp
+++ b/core/launcher/main.cpp
@@ -1,191 +1,194 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of 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 "desktop.h"
 #include "taskbar.h"
 #include "stabmon.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/network.h>
 #include <qpe/config.h>
 #if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
 #include <qpe/custom.h>
 #endif
 
 #include <opie/odevice.h>
+#include <opie/oprocess.h>
 
 #include <qmessagebox.h>
 #include <qfile.h>
 #include <qimage.h>
 #include <qwindowsystem_qws.h>
 #include <qwsmouse_qws.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/alarmserver.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <signal.h>
 #include <unistd.h>
 
-#include "../calibrate/calibrate.h"
-
 using namespace Opie;
 
 void initEnvironment()
 {
     int rot;
     Config config("locale");
     
     config.setGroup( "Location" );
     QString tz = config.readEntry( "Timezone", getenv("TZ") );
 
   // if not timezone set, pick New York
     if (tz.isNull())
         tz = "America/New_York";
 
     setenv( "TZ", tz, 1 );
     config.writeEntry( "Timezone", tz);
 
     config.setGroup( "Language" );
     QString lang = config.readEntry( "Language", getenv("LANG") );
     if ( !lang.isNull() )
         setenv( "LANG", lang, 1 );
 
 #if !defined(QT_QWS_CASSIOPEIA) && !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX)
     setenv( "QWS_SIZE", "240x320", 0 );
 #endif
 
     QString env(getenv("QWS_DISPLAY"));
     if (env.contains("Transformed")) {
         // 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 */
     }
 }
 
 
 int initApplication( int argc, char ** argv )
 {
     initEnvironment();
 
     //Don't flicker at startup:
     QWSServer::setDesktopBackground( QImage() );
 
     DesktopApplication a( argc, argv, QApplication::GuiServer );
 
     ODevice::inst ( )-> setSoftSuspend ( true );
 
     { // init backlight
         QCopEnvelope e("QPE/System", "setBacklight(int)" );
           e << -3; // Forced on
     }
 
     AlarmServer::initialize();
 
     Desktop *d = new Desktop();
 
     QObject::connect( &a, SIGNAL(power()),   d, SLOT(togglePower()) );
     QObject::connect( &a, SIGNAL(backlight()),   d, SLOT(toggleLight()) );
     QObject::connect( &a, SIGNAL(symbol()),   d, SLOT(toggleSymbolInput()) );
     QObject::connect( &a, SIGNAL(numLockStateToggle()),   d, SLOT(toggleNumLockState()) );
     QObject::connect( &a, SIGNAL(capsLockStateToggle()),   d, SLOT(toggleCapsLockState()) );
     QObject::connect( &a, SIGNAL(prepareForRestart()),   d, SLOT(terminateServers()) );
 
     (void)new SysFileMonitor(d);
     Network::createServer(d);
 
     if ( QWSServer::mouseHandler() ->inherits("QCalibratedMouseHandler") ) {
         if ( !QFile::exists( "/etc/pointercal" ) ) {
-            // Make sure calibration widget starts on top.
-            Calibrate *cal = new Calibrate;
-            cal->exec();
-            delete cal;
+            OProcess cal;
+            cal << "calibrate";
+          
+            if ( ! cal.start(OProcess::Block, OProcess::NoCommunication) ) {
+                QMessageBox::warning( 0, "Unable to calibrate",
+                    "Failed to start the calibration tool.\n"
+                );
+            }
         }
     }
 
     d->show();
 
         if ( QDate::currentDate ( ). year ( ) < 2000 ) {
                 if ( QMessageBox::information ( 0, DesktopApplication::tr( "Information" ), DesktopApplication::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();
 
     delete d;
 
         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 ( );
 }
 
 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 );
 
     // Kill them. Kill them all.
     ::kill ( 0, SIGTERM );
     ::sleep ( 1 );
     ::kill ( 0, SIGKILL );
 
     return retVal;
 }
 
diff --git a/core/launcher/opie-taskbar.control b/core/launcher/opie-taskbar.control
index c0430b7..db66a05 100644
--- a/core/launcher/opie-taskbar.control
+++ b/core/launcher/opie-taskbar.control
@@ -1,9 +1,9 @@
-Files: bin/qpe apps/Settings/Calibrate.desktop pics/launcher pics/devicebuttons/*.png plugins/applets/libsuspendapplet.so* plugins/applets/libhomeapplet.so* plugins/applets/liblogoutapplet.so* plugins/applets/librotateapplet.so* root/etc/init.d/opie
+Files: bin/qpe pics/launcher pics/devicebuttons/*.png plugins/applets/libsuspendapplet.so* plugins/applets/libhomeapplet.so* plugins/applets/liblogoutapplet.so* plugins/applets/librotateapplet.so* root/etc/init.d/opie
 Priority: required
 Section: opie/system
 Maintainer: Project Opie <opie@handhelds.org>
 Architecture: arm
 Version: $QPE_VERSION-$SUB_VERSION.3
-Depends: opie-base
+Depends: opie-base, opie-calibrate
 Replaces: opie-rotation
 Description: Launcher for Opie
diff --git a/core/launcher/taskbar.cpp b/core/launcher/taskbar.cpp
index 8af568d..8158128 100644
--- a/core/launcher/taskbar.cpp
+++ b/core/launcher/taskbar.cpp
@@ -1,344 +1,329 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of 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 "startmenu.h"
 #include "inputmethods.h"
 #include "runningappbar.h"
 #include "systray.h"
-#include "calibrate.h"
 #include "wait.h"
 #include "appicons.h"
 
 #include "taskbar.h"
 #include "desktop.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/global.h>
 
 #if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
 #include <qpe/custom.h>
 #endif
 
 #include <opie/odevice.h>
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qtimer.h>
 #include <qwindowsystem_qws.h>
 #include <qwidgetstack.h>
 
 #if defined( Q_WS_QWS )
 #include <qwsdisplay_qws.h>
 #include <qgfx_qws.h>
 #endif
 
 
 using namespace Opie;
 
 #define FACTORY(T) \
     static QWidget *new##T( bool maximized ) { \
   QWidget *w = new T( 0, "test", 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 "../launcher/apps.h"
 #undef APP
 #endif // SINGLE_APP
 
 static Global::Command builtins[] = {
 
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) { a, new##b, c },
 #include "../launcher/apps.h"
 #undef APP
 #endif
 
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_SL5XXX)
-        { "calibrate",          TaskBar::calibrate, 1, 0 },
-#endif
 #if !defined(QT_QWS_CASSIOPEIA)
   { "shutdown",           Global::shutdown,   1, 0 },
 //  { "run",                run,      1, 0 },
 #endif
 
-  { 0,            TaskBar::calibrate, 0, 0 },
+  { 0, 0, 0, 0 },
 };
 
 static bool initNumLock()
 {
 #ifdef QPE_INITIAL_NUMLOCK_STATE
     QPE_INITIAL_NUMLOCK_STATE
 #endif
     return FALSE;
 }
 
 class LockKeyState : public QWidget
 {
 public:
     LockKeyState( QWidget *parent ) :
   QWidget(parent),
   nl(initNumLock()), cl(FALSE)
     {
   nl_pm = Resource::loadPixmap("numlock");
   cl_pm = Resource::loadPixmap("capslock");
     }
     QSize sizeHint() const
     {
   return QSize(nl_pm.width()+2,nl_pm.width()+nl_pm.height()+1);
     }
     void toggleNumLockState()
     {
   nl = !nl; repaint();
     }
     void toggleCapsLockState()
     {
   cl = !cl; repaint();
     }
     void paintEvent( QPaintEvent * )
     {
   int y = (height()-sizeHint().height())/2;
   QPainter p(this);
   if ( nl )
       p.drawPixmap(1,y,nl_pm);
   if ( cl )
       p.drawPixmap(1,y+nl_pm.height()+1,cl_pm);
     }
 private:
     QPixmap nl_pm, cl_pm;
     bool nl, cl;
 };
 
 TaskBar::~TaskBar()
 {
 }
 
 
 TaskBar::TaskBar() : QHBox(0, 0, WStyle_Customize | WStyle_Tool | WStyle_StaysOnTop | WGroupLeader)
 {
     Global::setBuiltinCommands(builtins);
 
     sm = new StartMenu( this );
 
     inputMethods = new InputMethods( this );
     connect( inputMethods, SIGNAL(inputToggled(bool)),
        this, SLOT(calcMaxWindowRect()) );
     //new QuickLauncher( this );
 
     stack = new QWidgetStack( this );
     stack->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
     label = new QLabel(stack);
 
     //mru = new MRUList( stack );
     //stack->raiseWidget( mru );
 
     runningAppBar = new RunningAppBar(stack);
     stack->raiseWidget(runningAppBar);
 
     waitIcon = new Wait( this );
     (void) new AppIcons( this );
 
     sysTray = new SysTray( this );
 
     // ## make customizable in some way? 
     lockState = new LockKeyState( this );
 
 #if defined(Q_WS_QWS)
 #if !defined(QT_NO_COP)
     QCopChannel *channel = new QCopChannel( "QPE/TaskBar", this );
     connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
   this, SLOT(receive(const QCString&, const QByteArray&)) );
 #endif
 #endif
     waitTimer = new QTimer( this );
     connect( waitTimer, SIGNAL( timeout() ), this, SLOT( stopWait() ) );
     clearer = new QTimer( this );
     QObject::connect(clearer, SIGNAL(timeout()), SLOT(clearStatusBar()));
     QObject::connect(clearer, SIGNAL(timeout()), sysTray, SLOT(show()));
 }
 
 void TaskBar::setStatusMessage( const QString &text )
 {
     if ( !text.isEmpty() ) {
         label->setText( text );
         stack->raiseWidget( label );
         if ( sysTray && ( label->fontMetrics().width( text ) > label->width() ) )
             sysTray->hide();
         clearer->start( 3000, TRUE );
     } else {
         clearStatusBar();
     }
 }
 
 void TaskBar::clearStatusBar()
 {
     label->clear();
     stack->raiseWidget(runningAppBar);
      //  stack->raiseWidget( mru );
 }
 
 void TaskBar::startWait()
 {
     waitIcon->setWaiting( true );
     // a catchall stop after 10 seconds...
     waitTimer->start( 10 * 1000, true );
 }
 
 void TaskBar::stopWait(const QString& /*app*/)
 {
     waitTimer->stop();
     //mru->addTask(sm->execToLink(app));
     waitIcon->setWaiting( false );
 }
 
 void TaskBar::stopWait()
 {
     waitTimer->stop();
 
     waitIcon->setWaiting( false );
 }
 
 void TaskBar::resizeEvent( QResizeEvent *e )
 {
     QHBox::resizeEvent( e );
     calcMaxWindowRect();
 }
 
 void TaskBar::styleChange( QStyle &s )
 {
     QHBox::styleChange( s );
     calcMaxWindowRect();
 }
 
 void TaskBar::calcMaxWindowRect()
 {
 #ifdef Q_WS_QWS
     QRect wr;
     int displayWidth  = qApp->desktop()->width();
     QRect ir = inputMethods->inputRect();
     if ( ir.isValid() ) {
   wr.setCoords( 0, 0, displayWidth-1, ir.top()-1 );
     } else {
   wr.setCoords( 0, 0, displayWidth-1, y()-1 );
     }
 
 #if QT_VERSION < 300
     QWSServer::setMaxWindowRect( qt_screen->mapToDevice(wr,
   QSize(qt_screen->width(),qt_screen->height()))
   );
 #else
     QWSServer::setMaxWindowRect( wr );
 #endif
 #endif
 }
 
 void TaskBar::receive( const QCString &msg, const QByteArray &data )
 {
         QDataStream stream( data, IO_ReadOnly );
         if ( msg == "message(QString)" ) {
                 QString text;
                 stream >> text;
                 setStatusMessage( text );
         } else if ( msg == "hideInputMethod()" ) {
                 inputMethods->hideInputMethod();
         } else if ( msg == "showInputMethod()" ) {
                 inputMethods->showInputMethod();
         } else if ( msg == "reloadInputMethods()" ) {
                 inputMethods->loadInputMethods();
         } else if ( msg == "reloadApps()" ) {
                         sm->reloadApps();               
         } else if ( msg == "reloadApplets()" ) {
                 sysTray->clearApplets();
                 sysTray->addApplets();
                 sm->reloadApplets();
         } else if ( msg == "soundAlarm()" ) {
                 DesktopApplication::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 );
                 }
         }
         else if ( msg == "toggleMenu()" ) {
                 if ( sm-> launchMenu-> isVisible ( ))
                         sm-> launch ( );
                 else {
                         QCopEnvelope e ( "QPE/System", "toggleApplicationMenu()" );
                 }
         }
         else if ( msg == "toggleStartMenu()" ) {
                 sm-> launch ( );
         }
 }
 
-QWidget *TaskBar::calibrate(bool)
-{
-#ifdef Q_WS_QWS
-    Calibrate *c = new Calibrate;
-    c->show();
-    return c;
-#else
-    return 0;
-#endif
-}
-
 void TaskBar::toggleNumLockState()
 {
     if ( lockState ) lockState->toggleNumLockState();
 }
 
 void TaskBar::toggleCapsLockState()
 {
     if ( lockState ) lockState->toggleCapsLockState();
 }
 
 void TaskBar::toggleSymbolInput()
 {
     if ( inputMethods->currentShown() == "Unicode" ) {
   inputMethods->hideInputMethod();
     } else {
   inputMethods->showInputMethod("Unicode");
     }
 }
 
 bool TaskBar::recoverMemory()
 {
     //eturn mru->quitOldApps();
     return true;
 }
 
diff --git a/core/launcher/taskbar.h b/core/launcher/taskbar.h
index a0bf395..575a8c9 100644
--- a/core/launcher/taskbar.h
+++ b/core/launcher/taskbar.h
@@ -1,85 +1,83 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of 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 __TASKBAR_H__
 #define __TASKBAR_H__
 
 #include <qhbox.h>
 
 class QLabel;
 class QTimer;
 class InputMethods;
 class Wait;
 class SysTray;
 //class MRUList;
 class RunningAppBar;
 class QWidgetStack;
 class QTimer;
 class QLabel;
 class StartMenu;
 class LockKeyState;
 
 class TaskBar : public QHBox {
     Q_OBJECT
 public:
     TaskBar();
     ~TaskBar();
 
-    static QWidget *calibrate( bool );
-
     bool recoverMemory();
 
     StartMenu *startMenu() const { return sm; }
 public slots:
     void startWait();
     void stopWait(const QString&);
     void stopWait();
     void clearStatusBar();
     void toggleNumLockState();
     void toggleCapsLockState();
     void toggleSymbolInput();
 
 protected:
     void resizeEvent( QResizeEvent * );
     void styleChange( QStyle & );
     void setStatusMessage( const QString &text );
 
 public slots:
     void calcMaxWindowRect();
 private slots:
     void receive( const QCString &msg, const QByteArray &data );
 
 private:
 
     QTimer *waitTimer;
     Wait *waitIcon;
     InputMethods *inputMethods;
     SysTray *sysTray;
     //  MRUList *mru;
     RunningAppBar* runningAppBar;
     QWidgetStack *stack;
     QTimer *clearer;
     QLabel *label;
     LockKeyState* lockState;
     StartMenu *sm;
 };
 
 
 #endif // __TASKBAR_H__