1 files changed, 4 insertions, 2 deletions

diff --git a/library/global.cpp b/library/global.cpp
index 5c89430..90954fe 100644
--- a/library/global.cpp
+++ b/library/global.cpp
@@ -120,194 +120,196 @@ void StartingAppList::add( const QString& name )
     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 provides application-wide global functions.
 
   The Global functions are grouped as follows:
   \tableofcontents
 
   \section1 User Interface
 
   The statusMessage() function provides short-duration messages to the
   user. The showInputMethod() function shows the current input method,
   and hideInputMethod() hides the input method.
 
   \section1 Document related
 
   The findDocuments() function creates a set of \link doclnk.html
   DocLnk\endlink objects in a particular folder.
 
   \section1 Filesystem related
 
   Global provides an applicationFileName() function that returns the
   full path of an application-specific file.
 
   The execute() function runs an application.
 
   \section1 Word list related
 
   A list of words relevant to the current locale is maintained by the
   system. The list is held in a \link qdawg.html DAWG\endlink
   (implemented by the QDawg class). This list is used, for example, by
   the pickboard input method.
 
   The global QDawg is returned by fixedDawg(); this cannot be updated.
   An updatable copy of the global QDawg is returned by addedDawg().
   Applications may have their own word lists stored in \l{QDawg}s
   which are returned by dawg(). Use addWords() to add words to the
   updateable copy of the global QDawg or to named application
   \l{QDawg}s.
 
   \section1 Quoting
 
   The shellQuote() function quotes a string suitable for passing to a
   shell. The stringQuote() function backslash escapes '\' and '"'
   characters.
 
   \section1 Hardware
 
-  The writeHWClock() function sets the hardware clock to the system
-  clock's date and time.
+  The implementation of the writeHWClock() function depends on the AlarmServer
+  implementation. If the AlarmServer is using atd the clock will be synced to
+  hardware. If opie-alarm is used the hardware clock will be synced before
+  suspending the device. opie-alarm is used by iPAQ and Zaurii implementation
 
   \ingroup qtopiaemb
 */
 
 /*!
   \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 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 = applicationFileName("Dictionary", name ) + ".dawg";
         QFile dawgfile(dawgfilename);
         if ( dawgfile.open(IO_ReadOnly) )
             r->readFile(dawgfilename);
     }
     return *r;
 }
 
 /*!
   \overload
   Adds \a wordlist to the addedDawg().