6 files changed, 6 insertions, 6 deletions

diff --git a/core/launcher/firstuse.cpp b/core/launcher/firstuse.cpp
index 3f769ae..57469cf 100644
--- a/core/launcher/firstuse.cpp
+++ b/core/launcher/firstuse.cpp
@@ -1,416 +1,416 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 // I need access to some things you don't normally get access to.
 
 #ifndef _MSC_VER
   //### revise to allow removal of translators under MSVC
 #define private public
 #define protected public
 #endif
 #include "firstuse.h"
 #include "inputmethods.h"
 #include "applauncher.h"
 #include "serverapp.h"
-#include <qtopia/custom.h>
+//#include <qtopia/custom.h>
 
 #include "calibrate.h"
 #include "documentlist.h"
 
 #include <qtopia/resource.h>
 #include <qtopia/qcopenvelope_qws.h>
 #include <qtopia/qpeapplication.h>
 #include <qtopia/config.h>
 #include <qtopia/applnk.h>
 #include <qtopia/mimetype.h>
 #include <qtopia/fontmanager.h>
 
 #include <qapplication.h>
 #include <qfile.h>
 #include <qpainter.h>
 #include <qcstring.h>
 #include <qsimplerichtext.h>
 #include <qcolor.h>
 #include <qpushbutton.h>
 #include <qhbox.h>
 #include <qlabel.h>
 #include <qtimer.h>
 
 #if defined( Q_WS_QWS )
 #include <qwsdisplay_qws.h>
 #include <qgfx_qws.h>
 #endif
 
 #include <qwindowsystem_qws.h>
 
 #include <stdlib.h>
 #include <sys/types.h>
 #if defined(Q_OS_LINUX) || defined(_OS_LINUX_)
 #include <unistd.h>
 #endif
 
 
 struct {
     bool enabled;
     const char *app;
     const char *start;
     const char *stop;
     const char *desc;
 }
 settingsTable [] =
 {
     { FALSE, "language", "raise()", "accept()", // No tr
         QT_TR_NOOP("Language") },
 #ifndef Q_OS_WIN32
     { FALSE, "systemtime", "raise()", "accept()", // No tr
         QT_TR_NOOP("Time and Date") },
 #endif
     { FALSE, "addressbook", "editPersonalAndClose()", "accept()", // No tr
         QT_TR_NOOP("Personal Information") },
     { FALSE, 0, 0, 0, 0 }
 };
 
 
 FirstUse::FirstUse(QWidget* parent, const char * name, WFlags wf) :
     QDialog( parent, name, TRUE, wf),
     transApp(0), transLib(0), needCalibrate(FALSE), currApp(-1),
     waitForExit(-1), waitingForLaunch(FALSE), needRestart(FALSE)
 {
     ServerApplication::allowRestart = FALSE;
     // we force our height beyound the maximum (which we set anyway)
     QRect desk = qApp->desktop()->geometry();
     setGeometry( 0, 0, desk.width(), desk.height() );
 
     connect(qwsServer, SIGNAL(newChannel(const QString&)),
         this, SLOT(newQcopChannel(const QString&)));
 
     // Create a DocumentList so appLauncher has appLnkSet to search
     docList = new DocumentList( 0, FALSE );
     appLauncher = new AppLauncher( this );
     connect( appLauncher, SIGNAL(terminated(int, const QString&)),
             this, SLOT(terminated(int, const QString&)) );
 
     // more hackery
     // I will be run as either the main server or as part of the main server
     QWSServer::setScreenSaverIntervals(0);
     loadPixmaps();
 
     //check if there is a language program
 #ifndef Q_OS_WIN32
     QString exeSuffix;
 #else
     QString exeSuffix(".exe");
 #endif
 
     for ( int i = 0; settingsTable[i].app; i++ ) {
         QString file = QPEApplication::qpeDir() + "bin/";
         file += settingsTable[i].app;
         file += exeSuffix;
         if ( QFile::exists(file) )
             settingsTable[i].enabled = TRUE;
     }
 
     setFocusPolicy(NoFocus);
 
     taskBar = new QWidget(0, 0, WStyle_Tool | WStyle_Customize | WStyle_StaysOnTop | WGroupLeader);
 
     inputMethods = new InputMethods(taskBar);
     connect(inputMethods, SIGNAL(inputToggled(bool)),
             this, SLOT(calcMaxWindowRect()));
 
     back = new QPushButton(tr("<< Back"), taskBar);
     back->setFocusPolicy(NoFocus);
     connect(back, SIGNAL(clicked()), this, SLOT(previousDialog()) );
 
     next = new QPushButton(tr("Next >>"), taskBar);
     next->setFocusPolicy(NoFocus);
     connect(next, SIGNAL(clicked()), this, SLOT(nextDialog()) );
 
     // need to set the geom to lower corner
     QSize sz = inputMethods->sizeHint();
     int buttonWidth = (width() - sz.width()) / 2;
     int x = 0;
 
     controlHeight = back->sizeHint().height();
 
     inputMethods->setGeometry(0,0, sz.width(), controlHeight );
     x += sz.width();
 
     back->setGeometry(x, 0, buttonWidth, controlHeight);
     x += buttonWidth;
     next->setGeometry(x, 0, buttonWidth, controlHeight);
 
     taskBar->setGeometry( 0, height() - controlHeight, desk.width(), controlHeight);
     taskBar->hide();
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     qDebug("Setting up QCop to QPE/System");
     QCopChannel* sysChannel = new QCopChannel( "QPE/System", this );
     connect(sysChannel, SIGNAL(received(const QCString &, const QByteArray &)),
             this, SLOT(message(const QCString &, const QByteArray &)) );
 #endif
     calcMaxWindowRect();
 
     m_calHandler = ( QWSServer::mouseHandler() && QWSServer::mouseHandler()->inherits("QCalibratedMouseHandler") ) ? true : false;
 
     if ( m_calHandler) {
         if ( !QFile::exists("/etc/pointercal") ) {
             needCalibrate = TRUE;
             grabMouse();
         }
     }
 
     Config config("locale");
     config.setGroup( "Language");
     lang = config.readEntry( "Language", "en");
 
     defaultFont = font();
 
     //###language/font hack; should look it up somewhere
 #ifdef Q_WS_QWS
     if ( lang == "ja" || lang == "zh_CN" || lang == "zh_TW" || lang == "ko" ) {
         QFont fn = FontManager::unicodeFont( FontManager::Proportional );
         qApp->setFont( fn, TRUE );
     }
 #endif
 }
 
 FirstUse::~FirstUse()
 {
     delete appLauncher;
     delete docList;
     delete taskBar;
     ServerApplication::allowRestart = TRUE;
 }
 
 void FirstUse::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,
                 qApp->desktop()->height() - controlHeight-1);
     }
 
 #if QT_VERSION < 0x030000
     QWSServer::setMaxWindowRect( qt_screen->mapToDevice(wr,
                 QSize(qt_screen->width(),qt_screen->height()))
                                );
 #else
     QWSServer::setMaxWindowRect( wr );
 #endif
 #endif
 }
 
 /* cancel current dialog, and bring up next */
 void FirstUse::nextDialog()
 {
     int prevApp = currApp;
     do {
         currApp++;
         qDebug( "currApp = %d", currApp );
         if ( settingsTable[currApp].app == 0 ) {
             if ( prevApp >= 0 && appLauncher->isRunning(settingsTable[prevApp].app) ) {
                 // The last application is still running.
                 // Tell it to stop, and when its done we'll come back
                 // to nextDialog and exit.
                 qDebug( "Waiting for %s to exit", settingsTable[prevApp].app );
                 QCopEnvelope e(QCString("QPE/Application/") + settingsTable[prevApp].app,
                         settingsTable[prevApp].stop );
                 currApp = prevApp;
             } else {
                 qDebug( "Done!" );
                 Config config( "qpe" );
                 config.setGroup( "Startup" );
                 config.writeEntry( "FirstUse", FALSE );
                 QPixmap pix = Resource::loadPixmap("bigwait");
                 QLabel *lblWait = new QLabel(0, "wait hack!", // No tr
                         QWidget::WStyle_Customize | QWidget::WDestructiveClose |
                         QWidget::WStyle_NoBorder | QWidget::WStyle_Tool |
                         QWidget::WStyle_StaysOnTop);
                 lblWait->setPixmap( pix );
                 lblWait->setAlignment( QWidget::AlignCenter );
                 lblWait->setGeometry( qApp->desktop()->geometry() );
                 lblWait->show();
                 qApp->processEvents();
                 QTimer::singleShot( 1000, lblWait, SLOT(close()) );
                 repaint();
                 close();
                 ServerApplication::allowRestart = TRUE;
             }
             return;
         }
     } while ( !settingsTable[currApp].enabled );
 
     if ( prevApp >= 0 && appLauncher->isRunning(settingsTable[prevApp].app) ) {
         qDebug( "Shutdown: %s", settingsTable[prevApp].app );
         QCopEnvelope e(QCString("QPE/Application/") + settingsTable[prevApp].app,
                         settingsTable[prevApp].stop );
         waitForExit = prevApp;
     } else {
         qDebug( "Startup: %s", settingsTable[currApp].app );
         QCopEnvelope e(QCString("QPE/Application/") + settingsTable[currApp].app,
                 settingsTable[currApp].start );
         waitingForLaunch = TRUE;
     }
 
     updateButtons();
 }
 
 /* accept current dialog and bring up previous */
 void FirstUse::previousDialog()
 {
     int prevApp = currApp;
     do {
         currApp--;
         if ( currApp < 0 ) {
             currApp = prevApp;
             return;
         }
     } while ( !settingsTable[currApp].enabled );
 
     if ( prevApp >= 0 ) {
         qDebug( "Shutdown: %s", settingsTable[prevApp].app );
         QCopEnvelope e(QCString("QPE/Application/") + settingsTable[prevApp].app,
                         settingsTable[prevApp].stop );
 /*
         if (settingsTable[prevApp].app == QString("systemtime"))
             QCopEnvelope e("QPE/Application/citytime", "close()");
 */
         waitForExit = prevApp;
     } else {
         qDebug( "Startup: %s", settingsTable[currApp].app );
         QCopEnvelope e(QCString("QPE/Application/") + settingsTable[currApp].app,
                 settingsTable[currApp].start );
         waitingForLaunch = TRUE;
     }
 
     updateButtons();
 }
 
 void FirstUse::message(const QCString &msg, const QByteArray &data)
 {
     QDataStream stream( data, IO_ReadOnly );
     if ( msg == "timeChange(QString)" ) {
         QString t;
         stream >> t;
         if ( t.isNull() )
             unsetenv("TZ");
         else
             setenv( "TZ", t.latin1(), 1 );
     }
 }
 
 void FirstUse::terminated( int, const QString &app )
 {
     qDebug( "--- terminated: %s", app.latin1() );
     if ( waitForExit != -1 && settingsTable[waitForExit].app == app ) {
         qDebug( "Startup: %s", settingsTable[currApp].app );
         if ( settingsTable[waitForExit].app == "language" ) { // No tr
             Config config("locale");
             config.setGroup( "Language");
             QString l = config.readEntry( "Language", "en");
             if ( l != lang ) {
                 reloadLanguages();
                 needRestart = TRUE;
                 lang = l;
             }
         }
         QCopEnvelope e(QCString("QPE/Application/") + settingsTable[currApp].app,
                 settingsTable[currApp].start );
         waitingForLaunch = TRUE;
         updateButtons();
         repaint();
         waitForExit = -1;
     } else if ( settingsTable[currApp].app == app ) {
         nextDialog();
     } else {
         back->setEnabled(TRUE);
         next->setEnabled(TRUE);
     }
 }
 
 void FirstUse::newQcopChannel(const QString& channelName)
 {
     qDebug("channel %s added", channelName.data() );
     QString prefix("QPE/Application/");
     if (channelName.startsWith(prefix)) {
         QString appName = channelName.mid(prefix.length());
         if ( currApp >= 0 && appName == settingsTable[currApp].app ) {
             qDebug( "Application: %s started", settingsTable[currApp].app );
             waitingForLaunch = FALSE;
             updateButtons();
             repaint();
         } else if (appName != "quicklauncher") {
             back->setEnabled(FALSE);
             next->setEnabled(FALSE);
         }
     }
 }
 
 void FirstUse::reloadLanguages()
 {
     // read language from config file.  Waiting on QCop takes too long.
     Config config("locale");
     config.setGroup( "Language");
     QString l = config.readEntry( "Language", "en");
     QString cl = getenv("LANG");
     qWarning("language message - " + l);
     // setting anyway...
     if (l.isNull() )
         unsetenv( "LANG" );
     else {
         qWarning("and its not null");
         setenv( "LANG", l.latin1(), 1 );
     }
 #ifndef QT_NO_TRANSLATION
     // clear old translators
 #ifndef _MSC_VER
   //### revise to allow removal of translators under MSVC
   if(qApp->translators) {
         qApp->translators->setAutoDelete(TRUE);
         delete (qApp->translators);
         qApp->translators = 0;
     }
 #endif
 
     // load translation tables
     transApp = new QTranslator(qApp);
     QString tfn = QPEApplication::qpeDir() + "i18n/"+l+"/qpe.qm";
     qWarning("loading " + tfn);
     if ( transApp->load(tfn) ) {
         qWarning("installing translator");
         qApp->installTranslator( transApp );
     } else  {
         delete transApp;
         transApp = 0;
     }
 
     transLib = new QTranslator(qApp);
     tfn = QPEApplication::qpeDir() + "i18n/"+l+"/libqpe.qm";
     qWarning("loading " + tfn);
     if ( transLib->load(tfn) ) {
         qWarning("installing translator library");
         qApp->installTranslator( transLib );
     } else  {
diff --git a/core/launcher/launcher.cpp b/core/launcher/launcher.cpp
index 35d404a..d697c43 100644
--- a/core/launcher/launcher.cpp
+++ b/core/launcher/launcher.cpp
@@ -1,416 +1,416 @@
 /**********************************************************************
 ** 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 <qtopia/global.h>
 #ifdef Q_WS_QWS
 #include <qtopia/qcopenvelope_qws.h>
 #endif
 #include <qtopia/resource.h>
 #include <qtopia/applnk.h>
 #include <qtopia/config.h>
 #include <qtopia/global.h>
 #include <qtopia/qpeapplication.h>
 #include <qtopia/mimetype.h>
 #include <qtopia/private/categories.h>
-#include <qtopia/custom.h>
+//#include <qtopia/custom.h>
 
 #include <qdir.h>
 #ifdef Q_WS_QWS
 #include <qwindowsystem_qws.h>
 #endif
 #include <qtimer.h>
 #include <qcombobox.h>
 #include <qvbox.h>
 #include <qlayout.h>
 #include <qstyle.h>
 #include <qpushbutton.h>
 #include <qtabbar.h>
 #include <qwidgetstack.h>
 #include <qlayout.h>
 #include <qregexp.h>
 #include <qmessagebox.h>
 #include <qframe.h>
 #include <qpainter.h>
 #include <qlabel.h>
 #include <qtextstream.h>
 #include <qpopupmenu.h>
 
 #include "startmenu.h"
 #include "taskbar.h"
 
 #include "serverinterface.h"
 #include "launcherview.h"
 #include "launcher.h"
 #include "server.h"
 
 #define QTOPIA_INTERNAL_FSLP
 #include <qtopia/lnkproperties.h>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/vfs.h>
 #include <mntent.h>
 #endif
 
 #ifdef Q_WS_QWS
 #include <qkeyboard_qws.h>
 #include <qpe/lnkproperties.h>
 #endif
 
 
 static bool isVisibleWindow( int );
 //===========================================================================
 
 LauncherTabWidget::LauncherTabWidget( Launcher* parent ) :
     QVBox( parent )
 {
     docLoadingWidgetEnabled = false;
     docLoadingWidget = 0;
     docLoadingWidgetProgress = 0;
     launcher = parent;
     categoryBar = new LauncherTabBar( this );
     QPalette pal = categoryBar->palette();
     pal.setColor( QColorGroup::Light, pal.color(QPalette::Active,QColorGroup::Shadow) );
     pal.setColor( QColorGroup::Background, pal.active().background().light(110) );
     categoryBar->setPalette( pal );
     stack = new QWidgetStack(this);
     connect( categoryBar, SIGNAL(selected(int)), this, SLOT(raiseTabWidget()) );
     categoryBar->show();
     stack->show();
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QCopChannel *channel = new QCopChannel( "QPE/Launcher", this );
     connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
              this, SLOT(launcherMessage(const QCString&, const QByteArray&)) );
     connect( qApp, SIGNAL(appMessage(const QCString&, const QByteArray&)),
              this, SLOT(appMessage(const QCString&, const QByteArray&)));
 #endif
 
     createDocLoadingWidget();
 }
 
 void LauncherTabWidget::createDocLoadingWidget()
 {
     // Construct the 'doc loading widget' shown when finding documents
 
     // ### LauncherView class needs changing to be more generic so
     // this widget can change its background similar to the iconviews
     // so the background for this matches
     docLoadingWidget = new LauncherView( stack );
     docLoadingWidget->hideIcons();
     QVBox *docLoadingVBox = new QVBox( docLoadingWidget );
 
     docLoadingVBox->setSpacing( 20 );
     docLoadingVBox->setMargin( 10 );
 
     QWidget *space1 = new QWidget( docLoadingVBox );
     docLoadingVBox->setStretchFactor( space1, 1 );
 
     QLabel *waitPixmap = new QLabel( docLoadingVBox );
     waitPixmap->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)5, (QSizePolicy::SizeType)5, waitPixmap->sizePolicy().hasHeightForWidth() ) );
     waitPixmap->setPixmap( Resource::loadPixmap( "bigwait" ) );
     waitPixmap->setAlignment( int( QLabel::AlignCenter ) );
 
     QLabel *textLabel = new QLabel( docLoadingVBox );
     textLabel->setText( tr( "<b>Finding Documents...</b>" ) );
     textLabel->setAlignment( int( QLabel::AlignCenter ) );
 
     docLoadingWidgetProgress = new QProgressBar( docLoadingVBox );
     docLoadingWidgetProgress->setProgress( 0 );
     docLoadingWidgetProgress->setCenterIndicator( TRUE );
     docLoadingWidgetProgress->setBackgroundMode( NoBackground ); // No flicker
     setProgressStyle();
 
     QWidget *space2 = new QWidget( docLoadingVBox );
     docLoadingVBox->setStretchFactor( space2, 1 );
 
     Config cfg("Launcher");
     cfg.setGroup( "Tab Documents" ); // No tr
     setTabViewAppearance( docLoadingWidget, cfg );
 
     stack->addWidget( docLoadingWidget, 0 );
 }
 
 void LauncherTabWidget::initLayout()
 {
     layout()->activate();
     docView()->setFocus();
     categoryBar->showTab("Documents");
 }
 
 void LauncherTabWidget::appMessage(const QCString& message, const QByteArray&)
 {
     if ( message == "nextView()" )
         categoryBar->nextTab();
 }
 
 void LauncherTabWidget::raiseTabWidget()
 {
     if ( categoryBar->currentView() == docView()
          && docLoadingWidgetEnabled ) {
         stack->raiseWidget( docLoadingWidget );
         docLoadingWidget->updateGeometry();
     } else {
         stack->raiseWidget( categoryBar->currentView() );
     }
 }
 
 void LauncherTabWidget::tabProperties()
 {
     LauncherView *view = categoryBar->currentView();
     QPopupMenu *m = new QPopupMenu( this );
     m->insertItem( tr("Icon View"), LauncherView::Icon );
     m->insertItem( tr("List View"), LauncherView::List );
     m->setItemChecked( (int)view->viewMode(), TRUE );
     int rv = m->exec( QCursor::pos() );
     if ( rv >= 0 && rv != view->viewMode() ) {
         view->setViewMode( (LauncherView::ViewMode)rv );
     }
 
     delete m;
 }
 
 void LauncherTabWidget::deleteView( const QString& id )
 {
     LauncherTab *t = categoryBar->launcherTab(id);
     if ( t ) {
         stack->removeWidget( t->view );
         delete t->view;
         categoryBar->removeTab( t );
     }
 }
 
 LauncherView* LauncherTabWidget::newView( const QString& id, const QPixmap& pm, const QString& label )
 {
     LauncherView* view = new LauncherView( stack );
     connect( view, SIGNAL(clicked(const AppLnk*)),
             this, SIGNAL(clicked(const AppLnk*)));
     connect( view, SIGNAL(rightPressed(AppLnk*)),
             this, SIGNAL(rightPressed(AppLnk*)));
 
     int n = categoryBar->count();
     stack->addWidget( view, n );
 
     LauncherTab *tab = new LauncherTab( id, view, pm, label );
     categoryBar->insertTab( tab, n-1 );
 
     if ( id == "Documents" )
         docview = view;
 
     qDebug("inserting %s at %d", id.latin1(), n-1 );
 
     Config cfg("Launcher");
     setTabAppearance( tab, cfg );
 
     cfg.setGroup( "GUI" );
     view->setBusyIndicatorType( cfg.readEntry( "BusyType", QString::null ) );
 
     return view;
 }
 
 LauncherView *LauncherTabWidget::view( const QString &id )
 {
     LauncherTab *t = categoryBar->launcherTab(id);
     if ( !t )
         return 0;
     return t->view;
 }
 
 LauncherView *LauncherTabWidget::docView()
 {
     return docview;
 }
 
 void LauncherTabWidget::setLoadingWidgetEnabled( bool v )
 {
     if ( v != docLoadingWidgetEnabled && docLoadingWidget ) {
         docLoadingWidgetEnabled = v;
         raiseTabWidget();
     }
 }
 
 void LauncherTabWidget::setLoadingProgress( int percent )
 {
     docLoadingWidgetProgress->setProgress( (percent / 4) * 4 );
 }
 
 // ### this function could more to LauncherView
 void LauncherTabWidget::setTabViewAppearance( LauncherView *v, Config &cfg )
 {
     // View
     QString view = cfg.readEntry( "View", "Icon" );
     if ( view == "List" ) // No tr
         v->setViewMode( LauncherView::List );
     QString bgType = cfg.readEntry( "BackgroundType", "Image" );
     if ( bgType == "Image" ) { // No tr
         QString pm = cfg.readEntry( "BackgroundImage", "launcher/opie-background" );
         v->setBackgroundType( LauncherView::Image, pm );
     } else if ( bgType == "SolidColor" ) {
         QString c = cfg.readEntry( "BackgroundColor" );
         v->setBackgroundType( LauncherView::SolidColor, c );
     } else {
         v->setBackgroundType( LauncherView::Ruled, QString::null );
     }
     QString textCol = cfg.readEntry( "TextColor" );
     if ( textCol.isEmpty() )
         v->setTextColor( QColor() );
     else
         v->setTextColor( QColor(textCol) );
 //    bool customFont = cfg.readBoolEntry( "CustomFont", FALSE );
 
 
     QStringList font = cfg.readListEntry( "Font", ',' );
     if ( font.count() == 4 )
         v->setViewFont( QFont(font[0], font[1].toInt(), font[2].toInt(), font[3].toInt()!=0) );
 
     // ### FIXME TabColor TabTextColor
 
 }
 
 // ### Could move to LauncherTab
 void LauncherTabWidget::setTabAppearance( LauncherTab *tab, Config &cfg )
 {
     cfg.setGroup( QString( "Tab %1" ).arg(tab->type) ); // No tr
 
     setTabViewAppearance( tab->view, cfg );
 
     // Tabs
     QString tabCol = cfg.readEntry( "TabColor" );
     if ( tabCol.isEmpty() )
         tab->bgColor = QColor();
     else
         tab->bgColor = QColor(tabCol);
     QString tabTextCol = cfg.readEntry( "TabTextColor" );
     if ( tabTextCol.isEmpty() )
         tab->fgColor = QColor();
     else
         tab->fgColor = QColor(tabTextCol);
 }
 
 void LauncherTabWidget::paletteChange( const QPalette &p )
 {
     QVBox::paletteChange( p );
     QPalette pal = palette();
     pal.setColor( QColorGroup::Light, pal.color(QPalette::Active,QColorGroup::Shadow) );
     pal.setColor( QColorGroup::Background, pal.active().background().light(110) );
     categoryBar->setPalette( pal );
     categoryBar->update();
 }
 
 void LauncherTabWidget::styleChange( QStyle & )
 {
     QTimer::singleShot( 0, this, SLOT(setProgressStyle()) );
 }
 
 void LauncherTabWidget::setProgressStyle()
 {
     if (docLoadingWidgetProgress) {
         docLoadingWidgetProgress->setFrameShape( QProgressBar::Box );
         docLoadingWidgetProgress->setFrameShadow( QProgressBar::Plain );
         docLoadingWidgetProgress->setMargin( 1 );
         docLoadingWidgetProgress->setLineWidth( 1 );
     }
 }
 
 void LauncherTabWidget::setBusy(bool on)
 {
     if ( on )
         currentView()->setBusy(TRUE);
     else {
         for ( int i = 0; i < categoryBar->count(); i++ ) {
             LauncherView *view = ((LauncherTab *)categoryBar->tab(i))->view;
             view->setBusy( FALSE );
         }
     }
 }
 
 void LauncherTabWidget::setBusyIndicatorType( const QString& str ) {
     for (int i = 0; i < categoryBar->count(); i++ ) {
         LauncherView* view = static_cast<LauncherTab*>( categoryBar->tab(i) )->view;
         view->setBusyIndicatorType( str );
     }
 }
 
 LauncherView *LauncherTabWidget::currentView(void)
 {
     return (LauncherView*)stack->visibleWidget();
 }
 
 
 
 void LauncherTabWidget::launcherMessage( const QCString &msg, const QByteArray &data)
 {
     QDataStream stream( data, IO_ReadOnly );
     if ( msg == "setTabView(QString,int)" ) {
         QString id;
         stream >> id;
         int mode;
         stream >> mode;
         if ( view(id) )
             view(id)->setViewMode( (LauncherView::ViewMode)mode );
     } else if ( msg == "setTabBackground(QString,int,QString)" ) {
         QString id;
         stream >> id;
         int mode;
         stream >> mode;
         QString pixmapOrColor;
         stream >> pixmapOrColor;
         if ( view(id) )
             view(id)->setBackgroundType( (LauncherView::BackgroundType)mode, pixmapOrColor );
         if ( id == "Documents" )
             docLoadingWidget->setBackgroundType( (LauncherView::BackgroundType)mode, pixmapOrColor );
     } else if ( msg == "setTextColor(QString,QString)" ) {
         QString id;
         stream >> id;
         QString color;
         stream >> color;
         if ( view(id) )
             view(id)->setTextColor( QColor(color) );
         if ( id == "Documents" )
             docLoadingWidget->setTextColor( QColor(color) );
     } else if ( msg == "setFont(QString,QString,int,int,int)" ) {
         QString id;
         stream >> id;
         QString fam;
         stream >> fam;
         int size;
         stream >> size;
         int weight;
         stream >> weight;
         int italic;
         stream >> italic;
         if ( view(id) ) {
             if ( !fam.isEmpty() ) {
                 view(id)->setViewFont( QFont(fam, size, weight, italic!=0) );
                 qDebug( "setFont: %s, %d, %d, %d", fam.latin1(), size, weight, italic );
             } else {
                 view(id)->clearViewFont();
             }
         }
     }else if ( msg == "setBusyIndicatorType(QString)" ) {
         QString type;
         stream >> type;
         setBusyIndicatorType( type );
     }else if ( msg == "home()" ) {
         if ( isVisibleWindow( static_cast<QWidget*>(parent())->winId() ) ) {
             if (categoryBar)
diff --git a/core/launcher/main.cpp b/core/launcher/main.cpp
index 5416d33..988e432 100644
--- a/core/launcher/main.cpp
+++ b/core/launcher/main.cpp
@@ -1,356 +1,356 @@
 /**********************************************************************
 ** 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/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 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;
 
 #ifndef Q_OS_MACX
     ODevice::inst()->setSoftSuspend( false );
 #endif
 
     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 4c62b78..6a140e9 100644
--- a/core/launcher/server.cpp
+++ b/core/launcher/server.cpp
@@ -1,436 +1,436 @@
 /**********************************************************************
 ** 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 <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(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");
diff --git a/core/launcher/serverapp.cpp b/core/launcher/serverapp.cpp
index 69e083d..23a7f95 100644
--- a/core/launcher/serverapp.cpp
+++ b/core/launcher/serverapp.cpp
@@ -1,417 +1,417 @@
 /**********************************************************************
 ** Copyright (C) 2000-2003 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 "serverapp.h"
 
 #include <opie/odevice.h>
 
 #include <qtopia/password.h>
 #include <qtopia/config.h>
 #include <qtopia/power.h>
 
 #ifdef Q_WS_QWS
 #include <qtopia/qcopenvelope_qws.h>
 #endif
 #include <qtopia/global.h>
-#include <qtopia/custom.h>
+//#include <qtopia/custom.h>
 
 #ifdef Q_WS_QWS
 #include <qgfx_qws.h>
 #endif
 #ifdef Q_OS_WIN32
 #include <io.h>
 #include <process.h>
 #else
 #include <unistd.h>
 #endif
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qpainter.h>
 #include <qfile.h>
 #include <qpixmapcache.h>
 
 #include <stdlib.h>
 #include "screensaver.h"
 
 static ServerApplication *serverApp = 0;
 static int loggedin=0;
 
 using namespace Opie;
 
 QCopKeyRegister::QCopKeyRegister()
     : m_keyCode( 0 ) {
 }
 
 QCopKeyRegister::QCopKeyRegister( int k, const QCString& c, const QCString& m )
     :m_keyCode( k ), m_channel( c ), m_message( m ) {
 }
 
 int QCopKeyRegister::keyCode()const {
     return m_keyCode;
 }
 
 QCString QCopKeyRegister::channel()const {
     return m_channel;
 }
 
 QCString QCopKeyRegister::message()const {
     return m_message;
 }
 
 bool QCopKeyRegister::send() {
     if (m_channel.isNull() )
         return false;
 
     QCopEnvelope( m_channel, m_message );
 
     return true;
 }
 
 //---------------------------------------------------------------------------
 
 /*
   Priority is number of alerts that are needed to pop up
   alert.
  */
 class DesktopPowerAlerter : public QMessageBox
 {
     Q_OBJECT
 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 Opie::ODeviceButton* button = Opie::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;
 
 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 )
 {
 
 
     // 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::ODeviceButton*,bool)),
             this,SIGNAL(activate(const Opie::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 Opie::ODeviceButton* but = Opie::ODevice::inst()->buttonForKeycode( -1 );
 }
 
 
 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 )
             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 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;
diff --git a/core/launcher/taskbar.cpp b/core/launcher/taskbar.cpp
index 2966168..491a8a3 100644
--- a/core/launcher/taskbar.cpp
+++ b/core/launcher/taskbar.cpp
@@ -1,377 +1,377 @@
 /**********************************************************************
 ** 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 "startmenu.h"
 #include "inputmethods.h"
 #include "runningappbar.h"
 #include "systray.h"
 #include "wait.h"
 #include "appicons.h"
 
 #include "taskbar.h"
 #include "server.h"
 
 #include <qtopia/config.h>
 #include <qtopia/qpeapplication.h>
 #ifdef QWS
 #include <qtopia/qcopenvelope_qws.h>
 #endif
 #include <qtopia/global.h>
-#include <qtopia/custom.h>
+//#include <qtopia/custom.h>
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qtimer.h>
 #ifdef QWS
 #include <qwindowsystem_qws.h>
 #endif
 #include <qwidgetstack.h>
 
 #if defined( Q_WS_QWS )
 #include <qwsdisplay_qws.h>
 #include <qgfx_qws.h>
 #endif
 
 
 static bool initNumLock()
 {
 #ifdef QPE_INITIAL_NUMLOCK_STATE
     QPE_INITIAL_NUMLOCK_STATE
 #endif
     return FALSE;
 }
 
 //---------------------------------------------------------------------------
 
 class SafeMode : public QWidget
 {
     Q_OBJECT
 public:
     SafeMode( QWidget *parent ) : QWidget( parent ), menu(0)
     {
         message = tr("Safe Mode");
         QFont f( font() );
         f.setWeight( QFont::Bold );
         setFont( f );
     }
 
     void mousePressEvent( QMouseEvent *);
     QSize sizeHint() const;
     void paintEvent( QPaintEvent* );
 
 private slots:
     void action(int i);
 
 private:
     QString message;
     QPopupMenu *menu;
 };
 
 void SafeMode::mousePressEvent( QMouseEvent *)
 {
     if ( !menu ) {
         menu = new QPopupMenu(this);
         menu->insertItem( tr("Plugin Manager..."), 0 );
         menu->insertItem( tr("Restart Qtopia"), 1 );
         menu->insertItem( tr("Help..."), 2 );
         connect(menu, SIGNAL(activated(int)), this, SLOT(action(int)));
     }
     QPoint curPos = mapToGlobal( QPoint(0,0) );
     QSize sh = menu->sizeHint();
     menu->popup( curPos-QPoint((sh.width()-width())/2,sh.height()) );
 }
 
 void SafeMode::action(int i)
 {
     switch (i) {
         case 0:
             Global::execute( "pluginmanager" );
             break;
         case 1:
             Global::restart();
             break;
         case 2:
             Global::execute( "helpbrowser", "safemode.html" );
             break;
     }
 }
 
 QSize SafeMode::sizeHint() const
 {
     QFontMetrics fm = fontMetrics();
 
     return QSize( fm.width(message), fm.height() );
 }
 
 void SafeMode::paintEvent( QPaintEvent* )
 {
     QPainter p(this);
     p.drawText( rect(), AlignCenter, message );
 }
 
 //---------------------------------------------------------------------------
 
 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)
 {
     Config cfg( "Launcher" );
     cfg.setGroup( "InputMethods" );
     resizeRunningApp = cfg.readBoolEntry( "Resize", true );
 
     sm = new StartMenu( this );
     connect( sm, SIGNAL(tabSelected(const QString&)), this,
             SIGNAL(tabSelected(const QString&)) );
 
     inputMethods = new InputMethods( this );
     connect( inputMethods, SIGNAL(inputToggled(bool)),
              this, SLOT(calcMaxWindowRect()) );
 
     stack = new QWidgetStack( this );
     stack->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
     label = new QLabel(stack);
 
     runningAppBar = new RunningAppBar(stack);
     stack->raiseWidget(runningAppBar);
 
     waitIcon = new Wait( this );
     (void) new AppIcons( this );
 
     sysTray = new SysTray( this );
 
     /* ### FIXME plugin loader and safe mode */
 #if 0
     if (PluginLoader::inSafeMode())
         (void)new SafeMode( this );
 #endif
 
     // ## make customizable in some way?
 #ifdef QT_QWS_CUSTOM
     lockState = new LockKeyState( this );
 #else
     lockState = 0;
 #endif
 
 #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()));
 
     connect( qApp, SIGNAL(symbol()), this, SLOT(toggleSymbolInput()) );
     connect( qApp, SIGNAL(numLockStateToggle()), this, SLOT(toggleNumLockState()) );
     connect( qApp, SIGNAL(capsLockStateToggle()), this, SLOT(toggleCapsLockState()) );
 }
 
 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);
     if ( sysTray )
         sysTray->show();
     //     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&)
 {
     waitTimer->stop();
     waitIcon->setWaiting( false );
 }
 
 void TaskBar::stopWait()
 {
     waitTimer->stop();
     waitIcon->setWaiting( false );
 }
 
 /*
  * This resizeEvent will be captured by
  * the ServerInterface and it'll layout
  * and calc rect. Now if we go from bigger
  * to smaller screen the SysTray is out of
  * bounds and repaint() won't trigger an Event
  */
 void TaskBar::resizeEvent( QResizeEvent *e )
 {
     if ( sysTray )
         sysTray->hide();
 
     QHBox::resizeEvent( e );
 
     if ( sysTray )
         sysTray->show();
 
     qWarning("TaskBar::resize event");
 }
 
 void TaskBar::styleChange( QStyle &s )
 {
     QHBox::styleChange( s );
     calcMaxWindowRect();
 }
 
 void TaskBar::calcMaxWindowRect()
 {
     if ( resizeRunningApp )
     {
     #if defined(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 < 0x030000
         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 == "showInputMethod(QString)" ) {
         QString name;
         stream >> name;
         inputMethods->showInputMethod(name);
     } else if ( msg == "reloadInputMethods()" ) {
         inputMethods->loadInputMethods();
     } else if ( msg == "reloadApplets()" ) {
         sysTray->clearApplets();
         sm->createMenu();
         sysTray->addApplets();
     }else if ( msg == "toggleMenu()" ) {
         if ( sm-> launchMenu-> isVisible() )
             sm-> launch();
         else
             QCopEnvelope e( "QPE/System", "toggleApplicationMenu()" );
     }else if ( msg == "toggleStartMenu()" )
         sm->launch();
 }
 
 void TaskBar::setApplicationState( const QString &name, ServerInterface::ApplicationState state )
 {
     if ( state == ServerInterface::Launching )
         runningAppBar->applicationLaunched( name );
     else if ( state == ServerInterface::Terminated )
         runningAppBar->applicationTerminated( name );
 }
 
 void TaskBar::toggleNumLockState()
 {
     if ( lockState ) lockState->toggleNumLockState();
 }
 
 void TaskBar::toggleCapsLockState()
 {
     if ( lockState ) lockState->toggleCapsLockState();
 }
 
 void TaskBar::toggleSymbolInput()
 {
     QString unicodeInput = qApp->translate( "InputMethods", "Unicode" );
     if ( inputMethods->currentShown() == unicodeInput ) {
         inputMethods->hideInputMethod();
     } else {
         inputMethods->showInputMethod( unicodeInput );
     }
 }
 
 #include "taskbar.moc"