1 files changed, 49 insertions, 6 deletions

diff --git a/library/global.cpp b/library/global.cpp
index fd7579a..dd15eb7 100644
--- a/library/global.cpp
+++ b/library/global.cpp
@@ -1,274 +1,281 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
+#define QTOPIA_INTERNAL_LANGLIST
 #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("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;
+	QString words_lang;
+	QStringList langs = Global::languageList();
+	for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
+	    QString lang = *it;
+	    words_lang = dictDir() + "/words." + lang;
+	    QString dawgfilename_lang = dawgfilename + "." + lang;
+	    if ( QFile::exists(dawgfilename_lang) ||
+		 QFile::exists(words_lang) ) {
+		dawgfilename = dawgfilename_lang;
+		break;
+	    }
+	}
 	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");
@@ -546,99 +553,135 @@ void Global::execute( const QString &c, const QString& document )
 		    running[i]->show();
 		    running[i]->setActiveWindow();
 		} else {
 		    running[i] = builtin[i].func( builtin[i].maximized );
 		}
 		QCopEnvelope e("QPE/System", "notBusy(QString)" );
 		e << c; // that was quick ;-)
 		return;
 	    }
 	}
     }
 
     //Global::invoke(c, document);
 
     // Convert the command line in to a list of arguments
     QStringList list = QStringList::split(QRegExp("  *"),c);
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QString ap=list[0];
 
     qDebug("executing %s", ap.latin1() );
     if ( ap == "suspend" ) {
 	QWSServer::sendKeyEvent( 0xffff, Qt::Key_F34, FALSE, TRUE, FALSE );	
 	return;
     }
 
     /* if need be, sending a qcop message will result in an invoke, see 
        preceeding function */
     { QCopEnvelope env( ("QPE/Application/" + ap).latin1(), "raise()" ); }
     if ( !document.isEmpty() ) {
 	QCopEnvelope env( ("QPE/Application/" + ap).latin1(), "setDocument(QString)" );
 	env << document;
     }
 #endif
 }
 
 /*!
   Returns the string \a s with the characters backslash, ", and $
   quoted by a preceeding backslash.
 */
 QString Global::shellQuote(const QString& s)
 {
     QString r="\"";
     for (int i=0; i<(int)s.length(); i++) {
 	char c = s[i].latin1();
 	switch (c) {
 	    case '\\': case '"': case '$':
 		r+="\\";
 	}
 	r += s[i];
     }
     r += "\"";
     return r;
 }
 
 /*!
   Returns the string \a s with the characters backslash and "
   quoted by a preceeding backslash.
 */
 QString Global::stringQuote(const QString& s)
 {
     QString r="\"";
     for (int i=0; i<(int)s.length(); i++) {
 	char c = s[i].latin1();
 	switch (c) {
 	    case '\\': case '"':
 		r+="\\";
 	}
 	r += s[i];
     }
     r += "\"";
     return r;
 }
 
 /*!
   Finds all documents on the system's document directories which
   match the filter \a mimefilter, and appends the resulting DocLnk
   objects to \a folder.
 */
 void Global::findDocuments(DocLnkSet* folder, const QString &mimefilter)
 {
     QString homedocs = QString(getenv("HOME")) + "/Documents";
     DocLnkSet d(homedocs,mimefilter);
     folder->appendFrom(d);
     StorageInfo storage;
     const QList<FileSystem> &fs = storage.fileSystems();
     QListIterator<FileSystem> it ( fs );
     for ( ; it.current(); ++it ) {
 	if ( (*it)->isRemovable() ) {
 	    QString path = (*it)->path();
 	    DocLnkSet ide( path, mimefilter );
 	    folder->appendFrom(ide);
 	}
     }
 }
 
+QStringList Global::languageList()
+{
+    QString lang = getenv("LANG");
+    QStringList langs;
+    langs.append(lang);
+    int i  = lang.find(".");
+    if ( i > 0 )
+	lang = lang.left( i );
+    i = lang.find( "_" );
+    if ( i > 0 )
+	langs.append(lang.left(i));
+    return langs;
+}
+
+QStringList Global::helpPath()
+{
+    QStringList path;
+    QStringList langs = Global::languageList();
+    for (QStringList::ConstIterator it = langs.fromLast(); it!=langs.end(); --it) {
+	QString lang = *it;
+	if ( !lang.isEmpty() )
+	    path += QPEApplication::qpeDir() + "/help/" + lang + "/html";
+    }
+    path += QPEApplication::qpeDir() + "/pics";
+    path += QPEApplication::qpeDir() + "/help/en/html";
+    path += QPEApplication::qpeDir() + "/docs";
+    QString dir = QDir::current().canonicalPath();
+    if ( dir == "/" )
+	dir += "/docs";
+    else {
+	path += dir + "/../pics";
+	dir += "/../docs";
+	path += dir;
+    }
+    return path;
+}
 
 
 #include "global.moc"