1 files changed, 1 insertions, 1 deletions

diff --git a/library/global.cpp b/library/global.cpp
index e1bbf3e..e5fc2b3 100644
--- a/library/global.cpp
+++ b/library/global.cpp
@@ -1,329 +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 <qpe/qpedebug.h>
 #include <qpe/global.h>
 #include <qpe/qdawg.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 #include <qpe/applnk.h>
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #include "qpe/qcopenvelope_qws.h"
 #endif
 
 #include <qfile.h>
 #include <qlabel.h>
 #include <qtimer.h>
 #include <qmap.h>
 #include <qdict.h>
 #include <qdir.h>
 #include <qmessagebox.h>
 #include <qregexp.h>
 
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 #include <qwindowsystem_qws.h> // for qwsServer
 #include <qdatetime.h>
 
 //#include "quickexec_p.h"
 
 class Emitter : public QObject {
     Q_OBJECT
 public:
     Emitter( QWidget* receiver, const QString& document )
     {
         connect(this, SIGNAL(setDocument(const QString&)),
             receiver, SLOT(setDocument(const QString&)));
         emit setDocument(document);
         disconnect(this, SIGNAL(setDocument(const QString&)),
                receiver, SLOT(setDocument(const QString&)));
     }
 
 signals:
     void setDocument(const QString&);
 };
 
 
 class StartingAppList : public QObject {
     Q_OBJECT
 public:
     static void add( const QString& name );
     static bool isStarting( const QString name );
 private slots:
     void handleNewChannel( const QString &);
 private:
     StartingAppList( QObject *parent=0, const char* name=0 ) ;
 
     QDict<QTime> dict;
     static StartingAppList *appl;
 };
 
 StartingAppList* StartingAppList::appl = 0;
 
 StartingAppList::StartingAppList( QObject *parent, const char* name )
     :QObject( parent, name )
 {
 #if QT_VERSION >= 232 && !defined(QT_NO_COP)
     connect( qwsServer, SIGNAL( newChannel(const QString&)),
              this, SLOT( handleNewChannel(const QString&)) );
     dict.setAutoDelete( TRUE );
 #endif
 }
 
 void StartingAppList::add( const QString& name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
     if ( !appl )
         appl = new StartingAppList;
     QTime *t = new QTime;
     t->start();
     appl->dict.insert( "QPE/Application/" + name, t );
 #endif
 }
 
 bool StartingAppList::isStarting( const QString name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
     if ( appl ) {
         QTime *t  = appl->dict.find( "QPE/Application/" + name );
         if ( !t )
             return FALSE;
         if ( t->elapsed() > 10000 ) {
             // timeout in case of crash or something
             appl->dict.remove( "QPE/Application/" + name );
             return FALSE;
         }
         return TRUE;
     }
 #endif
     return FALSE;
 }
 
 void StartingAppList::handleNewChannel( const QString & name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
     dict.remove( name );
 #endif
 }
 
 static bool docDirCreated = FALSE;
 static QDawg* fixed_dawg = 0;
 static QDict<QDawg> *named_dawg = 0;
 
 static QString qpeDir()
 {
-    QString dir = getenv("QPEDIR");
+    QString dir = getenv("OPIEDIR");
     if ( dir.isEmpty() ) dir = "..";
     return dir;
 }
 
 static QString dictDir()
 {
     return qpeDir() + "/etc/dict";
 }
 
 /*!
   \class Global global.h
   \brief The Global class collects application-wide global functions.
 */
 
 /*!
   \internal
 */
 Global::Global()
 {
 }
 
 /*!
   Returns the unchangeable QDawg that contains general
   words for the current locale.
 
   \sa addedDawg()
 */
 const QDawg& Global::fixedDawg()
 {
     if ( !fixed_dawg ) {
         if ( !docDirCreated )
             createDocDir();
 
         fixed_dawg = new QDawg;
         QString dawgfilename = dictDir() + "/dawg";
         QString lang = getenv( "LANG" );
         QString dawgfilename_lang = dawgfilename + "." + lang;
         QString words_lang = dictDir() + "/words." + lang;
         if ( QFile::exists(dawgfilename_lang) ||
              QFile::exists(words_lang) )
             dawgfilename = dawgfilename_lang;
         QFile dawgfile(dawgfilename);
 
         if ( !dawgfile.exists() ) {
             QString fn = dictDir() + "/words";
             if ( QFile::exists(words_lang) )
                 fn = words_lang;
             QFile in(fn);
             if ( in.open(IO_ReadOnly) ) {
                 fixed_dawg->createFromWords(&in);
                 dawgfile.open(IO_WriteOnly);
                 fixed_dawg->write(&dawgfile);
                 dawgfile.close();
             }
         } else {
             fixed_dawg->readFile(dawgfilename);
         }
     }
 
     return *fixed_dawg;
 }
 
 /*!
   Returns the changeable QDawg that contains general
   words for the current locale.
 
   \sa fixedDawg()
 */
 const QDawg& Global::addedDawg()
 {
     return dawg("local");
 }
 
 /*!
   Returns the QDawg with the given \a name.
   This is an application-specific word list.
 
   \a name should not contain "/".
 */
 const QDawg& Global::dawg(const QString& name)
 {
     createDocDir();
     if ( !named_dawg )
         named_dawg = new QDict<QDawg>;
     QDawg* r = named_dawg->find(name);
     if ( !r ) {
         r = new QDawg;
         named_dawg->insert(name,r);
         QString dawgfilename = dictDir() + "/" + name + ".dawg";
         QFile dawgfile(dawgfilename);
         if ( dawgfile.open(IO_ReadOnly) )
             r->readFile(dawgfilename);
     }
     return *r;
 }
 
 /*!
   Adds \a wordlist to the addedDawg().
 */
 void Global::addWords(const QStringList& wordlist)
 {
     addWords("local",wordlist);
 }
 
 /*!
   Adds \a wordlist to the dawg() named \a dictname.
 */
 void Global::addWords(const QString& dictname, const QStringList& wordlist)
 {
     QDawg& d = (QDawg&)dawg(dictname);
     QStringList all = d.allWords() + wordlist;
     d.createFromWords(all);
 
     QString dawgfilename = dictDir() + "/" + dictname + ".dawg";
     QFile dawgfile(dawgfilename);
     if ( dawgfile.open(IO_WriteOnly) ) {
         d.write(&dawgfile);
         dawgfile.close();
     }
 
     // #### Re-read the dawg here if we use mmap().
 
     // #### Signal other processes to re-read.
 }
 
 
 /*!
   Returns a full path for the application named \a appname, with the
   given \a filename or QString::null if there was a problem creating
   the directory tree for \a appname.  
   If \a filename contains "/", it is the caller's responsibility to 
   ensure those directories exist.
 */
 QString Global::applicationFileName(const QString& appname, const QString& filename)
 {
     QDir d;
     QString r = getenv("HOME");
     r += "/Applications/";
     if ( !QFile::exists( r ) )
         if ( d.mkdir(r) == false )
             return QString::null;
     r += appname;
     if ( !QFile::exists( r ) )
         if ( d.mkdir(r) == false )
             return QString::null;
     r += "/"; r += filename;
     return r;
 }
 
 /*!
   \internal
 */
 void Global::createDocDir()
 {
     if ( !docDirCreated ) {
         docDirCreated = TRUE;
         mkdir( QPEApplication::documentDir().latin1(), 0755 );
     }
 }
 
 
 /*!
   Displays a status \a message to the user. This generally appears
   in the taskbar for some amount of time, then disappears.
 */
 void Global::statusMessage(const QString& message)
 {
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QCopEnvelope e( "QPE/TaskBar", "message(QString)" );
     e << message;
 #endif
 }
 
 /*!
   \internal
 */
 void Global::applyStyle()
 {
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QCopChannel::send( "QPE/System", "applyStyle()" );
 #else
     ((QPEApplication *)qApp)->applyStyle(); // apply without needing QCop for floppy version
 #endif
 }
 
 /*!
   \internal
 */
 QWidget *Global::shutdown( bool )
 {
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QCopChannel::send( "QPE/System", "shutdown()" );