2 files changed, 3 insertions, 3 deletions

diff --git a/core/launcher/applauncher.cpp b/core/launcher/applauncher.cpp
index f161e98..a8779a5 100644
--- a/core/launcher/applauncher.cpp
+++ b/core/launcher/applauncher.cpp
@@ -310,286 +310,286 @@ void AppLauncher::sigStopped(int sigPid, int sigStatus)
     bool crashed = WIFSIGNALED(sigStatus);
     if ( !crashed ) {
         if ( WIFEXITED(sigStatus) )
             exitStatus = WEXITSTATUS(sigStatus);
     } else {
         exitStatus  = WTERMSIG(sigStatus);
     }
 
     QMap<int,QString>::Iterator it = runningApps.find( sigPid );
     if ( it == runningApps.end() ) {
         if ( sigPid == qlPid ) {
             qDebug( "quicklauncher stopped" );
             qlPid = 0;
             qlReady = FALSE;
             QFile::remove("/tmp/qcop-msg-quicklauncher" );
             QTimer::singleShot( 2000, this, SLOT(createQuickLauncher()) );
         }
 /*
         if ( sigPid == -1 )
             qDebug("non-qtopia application exited (disregarded)");
         else
             qDebug("==== no pid matching %d in list, definite bug", sigPid);
 */
         return;
     }
     QString appName = *it;
     runningApps.remove(it);
 
     QMap<QString,int>::Iterator hbit = waitingHeartbeat.find(appName);
     if ( hbit != waitingHeartbeat.end() ) {
         killTimer( *hbit );
         waitingHeartbeat.remove( hbit );
     }
     if ( appName == appKillerName ) {
         appKillerName = QString::null;
         delete appKillerBox;
         appKillerBox = 0;
     }
 
     /* we must disable preload for an app that crashes as the system logic relies on preloaded apps
        actually being loaded.  If eg. the crash happened in the constructor, we can't automatically reload
        the app (withouth some timeout value for eg. 3 tries (which I think is a bad solution)
     */
     bool preloadDisabled = FALSE;
     if ( !DocumentList::appLnkSet ) return;
     const AppLnk* app = DocumentList::appLnkSet->findExec( appName );
     if ( !app ) return; // QCop messages processed to slow?
     if ( crashed && app->isPreloaded() ) {
         Config cfg("Launcher");
         cfg.setGroup("Preload");
         QStringList apps = cfg.readListEntry("Apps",',');
         QString exe = app->exec();
         apps.remove(exe);
         cfg.writeEntry("Apps",apps,',');
         preloadDisabled = TRUE;
     }
 
     // clean up
     if ( exitStatus ) {
         QCopEnvelope e("QPE/System", "notBusy(QString)");
         e << app->exec();
     }
 /*
     // debug info
     for (it = runningApps.begin(); it != runningApps.end(); ++it) {
         qDebug("running according to internal list: %s, with pid %d", (*it).data(), it.key() );
     }
 */
 
 #ifdef QTOPIA_PROGRAM_MONITOR
     if ( crashed ) {
         QString sig;
         switch( exitStatus ) {
             case SIGABRT: sig = "SIGABRT"; break;
             case SIGALRM: sig = "SIGALRM"; break;
             case SIGBUS: sig = "SIGBUS"; break;
             case SIGFPE: sig = "SIGFPE"; break;
             case SIGHUP: sig = "SIGHUP"; break;
             case SIGILL: sig = "SIGILL"; break;
             case SIGKILL: sig = "SIGKILL"; break;
             case SIGPIPE: sig = "SIGPIPE"; break;
             case SIGQUIT: sig = "SIGQUIT"; break;
             case SIGSEGV: sig = "SIGSEGV"; break;
             case SIGTERM: sig = "SIGTERM"; break;
             case SIGTRAP: sig = "SIGTRAP"; break;
             default: sig = QString("Unkown %1").arg(exitStatus);
         }
         if ( preloadDisabled )
             sig += tr("<qt><p>Fast loading has been disabled for this application.  Tap and hold the application icon to reenable it.</qt>");
 
         QString str = tr("<qt><b>%1</b> was terminated due to signal code %2</qt>").arg( app->name() ).arg( sig );
         QMessageBox::information(0, tr("Application terminated"), str );
     } else {
         if ( exitStatus == 255 ) {  //could not find app (because global returns -1)
             QMessageBox::information(0, tr("Application not found"), tr("<qt>Could not locate application <b>%1</b></qt>").arg( app->exec() ) );
         } else  {
-            QFileInfo fi(OGlobal::tempDirPath() + "qcop-msg-" + appName);
+            QFileInfo fi(QString::fromLatin1("/tmp/qcop-msg-") + appName);
             if ( fi.exists() && fi.size() ) {
                 emit terminated(sigPid, appName);
                 qWarning("Re executing obmitted for %s", appName.latin1() );
         //      execute( appName, QString::null );
                 return;
             }
         }
     }
 
 #endif
 
     emit terminated(sigPid, appName);
 }
 #else
 void AppLauncher::sigStopped(int sigPid, int sigStatus)
 {
     qDebug("Unhandled signal : AppLauncher::sigStopped(int sigPid, int sigStatus)");
 }
 #endif // Q_OS_WIN32
 
 bool AppLauncher::isRunning(const QString &app)
 {
     for (QMap<int,QString>::ConstIterator it = runningApps.begin(); it != runningApps.end(); ++it) {
         if ( *it == app ) {
 #ifdef Q_OS_UNIX
             pid_t t = ::__getpgid( it.key() );
             if ( t == -1 ) {
                 qDebug("appLauncher bug, %s believed running, but pid %d is not existing", app.data(), it.key() );
                 runningApps.remove( it.key() );
                 return FALSE;
             }
 #endif
             return TRUE;
         }
     }
 
     return FALSE;
 }
 
 bool AppLauncher::executeBuiltin(const QString &c, const QString &document)
 {
     Global::Command* builtin = OGlobal::builtinCommands();
     QGuardedPtr<QWidget> *running = OGlobal::builtinRunning();
 
     // Attempt to execute the app using a builtin class for the app
     if (builtin) {
         for (int i = 0; builtin[i].file; i++) {
             if ( builtin[i].file == c ) {
                 if ( running[i] ) {
                     if ( !document.isNull() && builtin[i].documentary )
                         Global::setDocument(running[i], document);
                     running[i]->raise();
                     running[i]->show();
                     running[i]->setActiveWindow();
                 } else {
                     running[i] = builtin[i].func( builtin[i].maximized );
                 }
 #ifndef QT_NO_COP
                 QCopEnvelope e("QPE/System", "notBusy(QString)" );
                 e << c; // that was quick ;-)
 #endif
                 return TRUE;
             }
         }
     }
 
     // Convert the command line in to a list of arguments
     QStringList list = QStringList::split(QRegExp("  *"),c);
     QString ap=list[0];
 
     if ( ap == "suspend" ) { // No tr
         QWSServer::processKeyEvent( 0xffff, Qt::Key_F34, FALSE, TRUE, FALSE );
         return TRUE;
     }
 
     return FALSE;
 }
 
 bool AppLauncher::execute(const QString &c, const QString &docParam, bool noRaise)
 {
     qWarning("AppLauncher::execute");
     // Convert the command line in to a list of arguments
     QStringList list = QStringList::split(QRegExp("  *"),c);
     if ( !docParam.isEmpty() )
         list.append( docParam );
 
     QString appName = list[0];
     if ( isRunning(appName) ) {
         QCString channel = "QPE/Application/";
         channel += appName.latin1();
 
         // Need to lock it to avoid race conditions with QPEApplication::processQCopFile
-        QFile f(OGlobal::tempDirPath() + "qcop-msg-" + appName);
+        QFile f(QString::fromLatin1("/tmp/qcop-msg-") + appName);
         if ( !noRaise && f.open(IO_WriteOnly | IO_Append) ) {
 #ifndef Q_OS_WIN32
             flock(f.handle(), LOCK_EX);
 #endif
 
             QDataStream ds(&f);
             QByteArray b;
             QDataStream bstream(b, IO_WriteOnly);
             if ( !f.size() ) {
                 ds << channel << QCString("raise()") << b;
                 if ( !waitingHeartbeat.contains( appName ) && appKillerName != appName ) {
                     int id = startTimer(RAISE_TIMEOUT_MS);
                     waitingHeartbeat.insert( appName, id );
                 }
             }
             if ( !docParam.isEmpty() ) {
                 bstream << docParam;
                 ds << channel << QCString("setDocument(QString)") << b;
             }
 
             f.flush();
 #ifndef Q_OS_WIN32
             flock(f.handle(), LOCK_UN);
 #endif
             f.close();
         }
         if ( QCopChannel::isRegistered(channel) ) // avoid unnecessary warnings
             QCopChannel::send(channel,"QPEProcessQCop()");
 
         return TRUE;
     }
 
 #ifdef QT_NO_QWS_MULTIPROCESS
     QMessageBox::warning( 0, tr("Error"), tr("<qt>Could not find the application %1</qt>").arg(c),
         tr("OK"), 0, 0, 0, 1 );
 #else
 
     QStrList slist;
     unsigned j;
     for ( j = 0; j < list.count(); j++ )
         slist.append( list[j].utf8() );
 
     const char **args = new const char *[slist.count() + 1];
     for ( j = 0; j < slist.count(); j++ )
         args[j] = slist.at(j);
     args[j] = NULL;
 
 #ifndef Q_OS_WIN32
 #ifdef Q_OS_MACX
     if ( qlPid && qlReady && QFile::exists( QPEApplication::qpeDir()+"plugins/application/lib"+args[0] + ".dylib" ) ) {
 #else
     if ( qlPid && qlReady && QFile::exists( QPEApplication::qpeDir()+"plugins/application/lib"+args[0] + ".so" ) ) {
 #endif /* Q_OS_MACX */
         qDebug( "Quick launching: %s", args[0] );
         if ( getuid() == 0 )
             setpriority( PRIO_PROCESS, qlPid, 0 );
         QCString qlch("QPE/QuickLauncher-");
         qlch += QString::number(qlPid);
         QCopEnvelope env( qlch, "execute(QStrList)" );
         env << slist;
         runningApps[qlPid] = QString(args[0]);
         emit launched(qlPid, QString(args[0]));
         QCopEnvelope e("QPE/System", "busy()");
         qlPid = 0;
         qlReady = FALSE;
         QTimer::singleShot( getuid() == 0 ? 800 : 1500, this, SLOT(createQuickLauncher()) );
     } else {
         int pid = ::vfork();
         if ( !pid ) {
             for ( int fd = 3; fd < 100; fd++ )
                 ::close( fd );
             ::setpgid( ::getpid(), ::getppid() );
             // Try bindir first, so that foo/bar works too
             ::execv( QPEApplication::qpeDir()+"bin/"+args[0], (char * const *)args );
             ::execvp( args[0], (char * const *)args );
             _exit( -1 );
         }
 
         runningApps[pid] = QString(args[0]);
         emit launched(pid, QString(args[0]));
         QCopEnvelope e("QPE/System", "busy()");
     }
 #else
     QProcess *proc = new QProcess(this);
     if (proc){
         for (int i=0; i < slist.count(); i++)
             proc->addArgument(args[i]);
         connect(proc, SIGNAL(processExited()), this, SLOT(processExited()));
         if (!proc->start()){
             qDebug("Unable to start application %s", args[0]);
         }else{
             PROCESS_INFORMATION *procInfo = (PROCESS_INFORMATION *)proc->processIdentifier();
             if (procInfo){
                 DWORD pid = procInfo->dwProcessId;
                 runningApps[pid] = QString(args[0]);
                 runningAppsProc.append(proc);
diff --git a/core/launcher/main.cpp b/core/launcher/main.cpp
index bf06e75..9e53bb0 100644
--- a/core/launcher/main.cpp
+++ b/core/launcher/main.cpp
@@ -1,171 +1,171 @@
 /**********************************************************************
 ** 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 <opie2/oglobal.h>
 
 #include <qtopia/qpeapplication.h>
 #include <qtopia/network.h>
 #include <qtopia/config.h>
 //#include <qtopia/custom.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 <opie2/odevice.h>
 
 using namespace Opie;
 
 
 static void cleanup()
 {
-    QDir dir( OGlobal::tempDirPath(), "qcop-msg-*" );
+    QDir dir( "/tmp", "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")) {