Config:

   Merged:
	void writeEntry( const QString &key, const QStringList &lst)
	QStringList readListEntry( const QString &key ) const
	void removeGroup()
	void removeGroup(const QString&)
	QStringList allGroups() const
   Uninlined:
        const versions of read*Entry
	bool hasGroup ( const QString &gname )const
	QStringList groupList ( )const

Marked these methods as NOT_IN_QPE, NOT_IN_SHARP, QTOPIA_MERGED_METHOD(version)
to make them weak by default and to know which functions needs to be defined
for possible SHARP.ROM versions

3 files changed, 182 insertions, 18 deletions

diff --git a/library/config.cpp b/library/config.cpp
index 664ca34..61ff089 100644
--- a/library/config.cpp
+++ b/library/config.cpp
@@ -1,580 +1,742 @@
 /**********************************************************************
-** Copyright (C) 2000 Trolltech AS.  All rights reserved.
+** Copyright (C) 2000,2004 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 <qdir.h>
 #include <qmessagebox.h>
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
 #include <qtextcodec.h>
 #endif
 #include <qtextstream.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #define QTOPIA_INTERNAL_LANGLIST
 #include "config.h"
 #include "global.h"
 
 
 /*!
   \internal
 */
 QString Config::configFilename(const QString& name, Domain d)
 {
     switch (d) {
 	case File:
 	    return name;
 	case User: {
 	    QDir dir = (QString(getenv("HOME")) + "/Settings");
 	    if ( !dir.exists() )
 		mkdir(dir.path().local8Bit(),0700);
 	    return dir.path() + "/" + name + ".conf";
 	}
     }
     return name;
 }
 
 /*!
   \class Config config.h
   \brief The Config class provides for saving application cofniguration state.
 
   You should keep a Config in existence only while you do not want others
   to be able to change the state. There is no locking currently, but there
   may be in the future.
 */
 
 /*!
   \enum Config::ConfigGroup
   \internal
 */
 
 /*!
   \enum Config::Domain
 
   \value File
   \value User
 
   See Config for details.
 */
 
 /*!
   Constructs a config that will load or create a configuration with the
   given \a name in the given \a domain.
 
   You must call setGroup() before doing much else with the Config.
 
   In the default Domain, \e User,
   the configuration is user-specific. \a name should not contain "/" in
   this case, and in general should be the name of the C++ class that is
   primarily responsible for maintaining the configuration.
 
   In the File Domain, \a name is an absolute filename.
 */
 Config::Config( const QString &name, Domain domain )
     : filename( configFilename(name,domain) )
 {
     git = groups.end();
     read();
     QStringList l = Global::languageList();
     lang = l[0];
     glang = l[1];
 }
 
 
 // Sharp ROM compatibility
 Config::Config ( const QString &name, bool what )
 	: filename( configFilename(name,what ? User : File) )
 {
     git = groups.end();
     read();
     QStringList l = Global::languageList();
     lang = l[0];
     glang = l[1];
 }
 
 /*!
   Writes any changes to disk and destroys the in-memory object.
 */
 Config::~Config()
 {
     if ( changed )
 	write();
 }
 
 /*!
   Returns whether the current group has an entry called \a key.
 */
 bool Config::hasKey( const QString &key ) const
 {
     if ( groups.end() == git )
 	return FALSE;
     ConfigGroup::ConstIterator it = ( *git ).find( key );
     return it != ( *git ).end();
 }
 
 /*!
   Sets the current group for subsequent reading and writing of
   entries to \a gname. Grouping allows the application to partition the namespace.
 
   This function must be called prior to any reading or writing
   of entries.
 
   The \a gname must not be empty.
 */
 void Config::setGroup( const QString &gname )
 {
     QMap< QString, ConfigGroup>::Iterator it = groups.find( gname );
     if ( it == groups.end() ) {
 	git = groups.insert( gname, ConfigGroup() );
 	changed = TRUE;
 	return;
     }
     git = it;
 }
 
 /*!
   Writes a (\a key, \a value) entry to the current group.
 
   \sa readEntry()
 */
 void Config::writeEntry( const QString &key, const char* value )
 {
     writeEntry(key,QString(value));
 }
 
 /*!
   Writes a (\a key, \a value) entry to the current group.
 
   \sa readEntry()
 */
 void Config::writeEntry( const QString &key, const QString &value )
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     if ( (*git)[key] != value ) {
 	( *git ).insert( key, value );
 	changed = TRUE;
     }
 }
 
 /*
   Note that the degree of protection offered by the encryption here is
   only sufficient to avoid the most casual observation of the configuration
   files. People with access to the files can write down the contents and
   decrypt it using this source code.
 
   Conceivably, and at some burden to the user, this encryption could
   be improved.
 */
 static QString encipher(const QString& plain)
 {
     // mainly, we make it long
     QString cipher;
     int mix=28730492;
     for (int i=0; i<(int)plain.length(); i++) {
 	int u = plain[i].unicode();
 	int c = u ^ mix;
 	QString x = QString::number(c,36);
 	cipher.append(QChar('a'+x.length()));
 	cipher.append(x);
 	mix *= u;
     }
     return cipher;
 }
 
 static QString decipher(const QString& cipher)
 {
     QString plain;
     int mix=28730492;
     for (int i=0; i<(int)cipher.length();) {
 	int l = cipher[i].unicode()-'a';
 	QString x = cipher.mid(i+1,l); i+=l+1;
 	int u = x.toInt(0,36) ^ mix;
 	plain.append(QChar(u));
 	mix *= u;
     }
     return plain;
 }
 
 /*!
   Writes an encrypted (\a key, \a value) entry to the current group.
 
   Note that the degree of protection offered by the encryption is
   only sufficient to avoid the most casual observation of the configuration
   files.
 
   \sa readEntry()
 */
 void Config::writeEntryCrypt( const QString &key, const QString &value )
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     QString evalue = encipher(value);
     if ( (*git)[key] != evalue ) {
 	( *git ).insert( key, evalue );
 	changed = TRUE;
     }
 }
 
 /*!
   Writes a (\a key, \a num) entry to the current group.
 
   \sa readNumEntry()
 */
 void Config::writeEntry( const QString &key, int num )
 {
     QString s;
     s.setNum( num );
     writeEntry( key, s );
 }
 
 #ifdef Q_HAS_BOOL_TYPE
 /*!
   Writes a (\a key, \a b) entry to the current group. This is equivalent
   to writing a 0 or 1 as an integer entry.
 
   \sa readBoolEntry()
 */
 void Config::writeEntry( const QString &key, bool b )
 {
     QString s;
     s.setNum( ( int )b );
     writeEntry( key, s );
 }
 #endif
 
 /*!
   Writes a (\a key, \a lst) entry to the current group. The list
   is separated by \a sep, so the strings must not contain that character.
 
   \sa readListEntry()
 */
 void Config::writeEntry( const QString &key, const QStringList &lst, const QChar &sep )
 {
     QString s;
     QStringList::ConstIterator it = lst.begin();
     for ( ; it != lst.end(); ++it )
 	s += *it + sep;
     writeEntry( key, s );
 }
 
 /*!
   Removes the \a key entry from the current group. Does nothing if
   there is no such entry.
 */
 
 void Config::removeEntry( const QString &key )
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     ( *git ).remove( key );
     changed = TRUE;
 }
 
 /*!
   \fn bool Config::operator == ( const Config & other ) const
 
   Tests for equality with \a other. Config objects are equal if they refer to the same filename.
 */
 
 /*!
   \fn bool Config::operator != ( const Config & other ) const
 
   Tests for inequality with \a other. Config objects are equal if they refer to the same filename.
 */
 
 /*!
   \fn QString Config::readEntry( const QString &key, const QString &deflt ) const
 
   Reads a string entry stored with \a key, defaulting to \a deflt if there is no entry.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QString Config::readEntry( const QString &key, const QString &deflt )
 {
     QString res = readEntryDirect( key+"["+lang+"]" );
     if ( !res.isNull() )
 	return res;
     if ( !glang.isEmpty() ) {
 	res = readEntryDirect( key+"["+glang+"]" );
 	if ( !res.isNull() )
 	    return res;
     }
     return readEntryDirect( key, deflt );
 }
 
 /*!
   \fn QString Config::readEntryCrypt( const QString &key, const QString &deflt ) const
 
   Reads an encrypted string entry stored with \a key, defaulting to \a deflt if there is no entry.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QString Config::readEntryCrypt( const QString &key, const QString &deflt )
 {
     QString res = readEntryDirect( key+"["+lang+"]" );
     if ( res.isNull() && glang.isEmpty() )
 	res = readEntryDirect( key+"["+glang+"]" );
     if ( res.isNull() )
 	res = readEntryDirect( key, QString::null );
     if ( res.isNull() )
 	return deflt;
     return decipher(res);
 }
 
 /*!
   \fn QString Config::readEntryDirect( const QString &key, const QString &deflt ) const
   \internal
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QString Config::readEntryDirect( const QString &key, const QString &deflt )
 {
     if ( git == groups.end() ) {
 	//qWarning( "no group set" );
 	return deflt;
     }
     ConfigGroup::ConstIterator it = ( *git ).find( key );
     if ( it != ( *git ).end() )
 	return *it;
     else
 	return deflt;
 }
 
 /*!
   \fn int Config::readNumEntry( const QString &key, int deflt ) const
   Reads a numeric entry stored with \a key, defaulting to \a deflt if there is no entry.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 int Config::readNumEntry( const QString &key, int deflt )
 {
     QString s = readEntry( key );
     if ( s.isEmpty() )
 	return deflt;
     else
 	return s.toInt();
 }
 
 /*!
   \fn bool Config::readBoolEntry( const QString &key, bool deflt ) const
   Reads a bool entry stored with \a key, defaulting to \a deflt if there is no entry.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 bool Config::readBoolEntry( const QString &key, bool deflt )
 {
     QString s = readEntry( key );
     if ( s.isEmpty() )
 	return deflt;
     else
 	return (bool)s.toInt();
 }
 
 /*!
   \fn QStringList Config::readListEntry( const QString &key, const QChar &sep ) const
   Reads a string list entry stored with \a key, and with \a sep as the separator.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QStringList Config::readListEntry( const QString &key, const QChar &sep )
 {
     QString s = readEntry( key );
     if ( s.isEmpty() )
 	return QStringList();
     else
 	return QStringList::split( sep, s );
 }
 
 /*!
   Removes all entries from the current group.
 */
 void Config::clearGroup()
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     if ( !(*git).isEmpty() ) {
 	( *git ).clear();
 	changed = TRUE;
     }
 }
 
 /*!
   \internal
 */
 void Config::write( const QString &fn )
 {
     QString strNewFile;
     if ( !fn.isEmpty() )
 	filename = fn;
     strNewFile = filename + ".new";
 
     QFile f( strNewFile );
     if ( !f.open( IO_WriteOnly|IO_Raw ) ) {
 	qWarning( "could not open for writing `%s'", strNewFile.latin1() );
 	git = groups.end();
 	return;
     }
 
     QString str;
     QCString cstr;
     QMap< QString, ConfigGroup >::Iterator g_it = groups.begin();
 
     for ( ; g_it != groups.end(); ++g_it ) {
         str += "[" + g_it.key() + "]\n";
         ConfigGroup::Iterator e_it = ( *g_it ).begin();
         for ( ; e_it != ( *g_it ).end(); ++e_it )
             str += e_it.key() + " = " + *e_it + "\n";
     }
     cstr = str.utf8();
 
     int total_length;
     total_length = f.writeBlock( cstr.data(), cstr.length() );
     if ( total_length != int(cstr.length()) ) {
 	QMessageBox::critical( 0, QObject::tr("Out of Space"),
 			       QObject::tr("There was a problem creating\nConfiguration Information \nfor this program.\n\nPlease free up some space and\ntry again.") );
 	f.close();
 	QFile::remove( strNewFile );
 	return;
     }
 
     f.close();
     // now rename the file...
     if ( rename( strNewFile, filename ) < 0 ) {
 	qWarning( "problem renaming the file %s to %s", strNewFile.latin1(),
 		  filename.latin1() );
 	QFile::remove( strNewFile );
     }
 }
 
 /*!
   Returns whether the Config is in a valid state.
 */
 bool Config::isValid() const
 {
     return groups.end() != git;
 }
 
 /*!
   \internal
 */
 void Config::read()
 {
     changed = FALSE;
 
     if ( !QFileInfo( filename ).exists() ) {
 	git = groups.end();
 	return;
     }
 
     QFile f( filename );
     if ( !f.open( IO_ReadOnly ) ) {
 	git = groups.end();
 	return;
     }
 
 
     // hack to avoid problems if big files are passed to test
     // if they are valid configs ( like passing a mp3 ... )
     // I just hope that there are no conf files > 100000 byte
     // not the best solution, find something else later
     if ( f.getch()!='[' ||f.size() > 100000 )  {
         git = groups.end();
         return;
     }
     f.ungetch('[');
 
 
     QTextStream s( &f );
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
     // The below should work, but doesn't in Qt 2.3.0
     s.setCodec( QTextCodec::codecForMib( 106 ) );
 #else
     s.setEncoding( QTextStream::UnicodeUTF8 );
 #endif
 
     QStringList list = QStringList::split('\n', s.read() );
     f.close();
 
     for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
         if ( !parse( *it ) ) {
             git = groups.end();
             return;
         }
     }
 }
 
 /*!
   \internal
 */
 bool Config::parse( const QString &l )
 {
     QString line = l.stripWhiteSpace();
 
     if ( line [0] == QChar ( '#' ))
         return true; // ignore comments
 
     if ( line[ 0 ] == QChar( '[' ) ) {
 	QString gname = line;
 	gname = gname.remove( 0, 1 );
 	if ( gname[ (int)gname.length() - 1 ] == QChar( ']' ) )
 	    gname = gname.remove( gname.length() - 1, 1 );
 	git = groups.insert( gname, ConfigGroup() );
     } else if ( !line.isEmpty() ) {
 	if ( git == groups.end() )
 	    return FALSE;
 	int eq = line.find( '=' );
 	if ( eq == -1 )
 	    return FALSE;
 	QString key = line.left(eq).stripWhiteSpace();
 	QString value = line.mid(eq+1).stripWhiteSpace();
 	( *git ).insert( key, value );
     }
     return TRUE;
 }
+
+
+
+bool Config::hasGroup( const QString& name )const {
+    return ( groups. find ( name ) != groups. end ( ));
+};
+
+QStringList Config::groupList()const {
+    QStringList sl;
+    for ( ConfigGroupMap::ConstIterator it = groups. begin ( ); it != groups. end ( ); ++it )
+        sl << it.key();
+
+    return sl;
+};
+
+/////////////
+// Qtopia 2.1 Functions
+//
+////////////
+
+QStringList Config::allGroups()const {
+    return groupList();
+}
+
+/*!
+  Returns the time stamp for the config identified by \a name.  The
+  time stamp represents the time the config was last committed to storage.
+  Returns 0 if there is no time stamp available for the config.
+
+  A \a domain can optionally be specified and defaults to User.
+  See \l{Config()} for details.
+
+  First availability: Qtopia 2.0
+*/
+long Config::timeStamp(const QString& name, Domain domain)
+{
+#ifdef Q_WS_WIN
+    // Too slow (many conversions too and from time_t and QDataTime)
+    QDateTime epoch;
+    epoch.setTime_t(0);
+    return epoch.secsTo(QFileInfo(Config::configFilename(name,domain)).lastModified());
+#else
+    QString fn = Config::configFilename(name,domain);
+    struct stat b;
+    if (lstat( QFile::encodeName(fn).data(), &b ) == 0)
+        return b.st_mtime;
+    else
+        return 0;
+#endif
+}
+
+
+/*!
+  Removes the current group (and all its entries).
+
+  The current group becomes unset.
+
+  First availability: Qtopia 2.0
+*/
+void Config::removeGroup()
+{
+    if ( git == groups.end() ) {
+        qWarning( "no group set" );
+        return;
+    }
+
+    groups.remove(git.key());
+    git = groups.end();
+    changed = TRUE;
+}
+
+/*!
+  Removes the current group (and all its entries).
+
+  The current group becomes unset.
+
+  First availability: Qtopia 2.0
+*/
+void Config::removeGroup(const QString& g)
+{
+    groups.remove(g);
+    git = groups.end();
+}
+
+
+
+/*!
+  Writes a (\a key, \a lst) entry to the current group.
+
+  The list is
+  separated by the two characters "^e", and "^" withing the strings
+  is replaced by "^^", such that the strings may contain any character,
+  including "^".
+
+  Null strings are also allowed, and are recorded as "^0" in the string.
+
+  First availability: Qtopia 2.0
+
+  \sa readListEntry()
+*/
+void Config::writeEntry( const QString &key, const QStringList &lst )
+{
+    QString s;
+    for (QStringList::ConstIterator it=lst.begin(); it!=lst.end(); ++it) {
+        QString el = *it;
+        if ( el.isNull() ) {
+            el = "^0";
+        } else {
+            el.replace(QRegExp("\\^"), "^^");
+        }
+        s+=el;
+        s+="^e"; // end of element
+    }
+    writeEntry(key, s);
+}
+
+/*!
+  Returns the string list entry stored using \a key and with
+  the escaped seperator convention described in writeListEntry().
+
+  First availability: Qtopia 2.0
+*/
+QStringList Config::readListEntry( const QString &key ) const
+{
+    QString value = readEntry( key, QString::null );
+    QStringList l;
+    QString s;
+    bool esc=FALSE;
+    for (int i=0; i<(int)value.length(); i++) {
+        if ( esc ) {
+            if ( value[i] == 'e' ) { // end-of-string
+                l.append(s);
+                s="";
+            } else if ( value[i] == '0' ) { // null string
+                s=QString::null;
+            } else {
+                s.append(value[i]);
+            }
+            esc = FALSE;
+        } else if ( value[i] == '^' ) {
+            esc = TRUE;
+        } else {
+            s.append(value[i]);
+            if ( i == (int)value.length()-1 )
+                l.append(s);
+        }
+    }
+    return l;
+}
+
+QString Config::readEntry( const QString &key, const QString &deflt ) const
+{ return ((Config*)this)->readEntry(key,deflt); }
+QString Config::readEntryCrypt( const QString &key, const QString &deflt ) const
+{ return ((Config*)this)->readEntryCrypt(key,deflt); }
+QString Config::readEntryDirect( const QString &key, const QString &deflt ) const
+{ return ((Config*)this)->readEntryDirect(key,deflt); }
+int Config::readNumEntry( const QString &key, int deflt ) const
+{ return ((Config*)this)->readNumEntry(key,deflt); }
+bool Config::readBoolEntry( const QString &key, bool deflt ) const
+{ return ((Config*)this)->readBoolEntry(key,deflt); }
+QStringList Config::readListEntry( const QString &key, const QChar &sep ) const
+{ return ((Config*)this)->readListEntry(key,sep); }
diff --git a/library/config.h b/library/config.h
index a2f9b2d..29ba0d6 100644
--- a/library/config.h
+++ b/library/config.h
@@ -1,109 +1,108 @@
 /**********************************************************************
-** Copyright (C) 2000 Trolltech AS.  All rights reserved.
+** Copyright (C) 2000, 2004 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.
 **
 **********************************************************************/
 
 #ifndef CONFIG_H
 #define CONFIG_H
 
 // ##### could use QSettings with Qt 3.0
 
+#include <qpe/qpeglobal.h>
+
 #include <qmap.h>
 #include <qstringlist.h>
 
+typedef QMap< QString, QString > ConfigGroup;
+typedef QMap< QString, ConfigGroup> ConfigGroupMap;
+
 class ConfigPrivate;
 class Config
 {
 public:
-    typedef QMap< QString, QString > ConfigGroup;
 
     enum Domain { File, User };
     Config( const QString &name, Domain domain=User );
     ~Config();
 
+    QTOPIA_MERGED_METHOD(static long timeStamp( const QString &name, Domain domain=User ), "2.1");
+
     bool operator == ( const Config & other ) const { return (filename == other.filename); }
     bool operator != ( const Config & other ) const { return (filename != other.filename); }
 
     bool isValid() const;
     bool hasKey( const QString &key ) const;
 
 	// inline for better SharpROM BC
-	inline bool hasGroup ( const QString &gname ) const  { return ( groups. find ( gname ) != groups. end ( )); };
-	inline QStringList groupList ( ) const { QStringList sl; for ( QMap< QString, ConfigGroup >::ConstIterator it = groups. begin ( ); it != groups. end ( ); ++it ) { sl << it.key(); } return sl; };
+    NOT_IN_QPE(bool hasGroup ( const QString &gname ) const);
+    NOT_IN_QPE(QStringList groupList ( ) const);
 
     void setGroup( const QString &gname );
     void writeEntry( const QString &key, const char* value );
     void writeEntry( const QString &key, const QString &value );
     void writeEntryCrypt( const QString &key, const QString &value );
     void writeEntry( const QString &key, int num );
 #ifdef Q_HAS_BOOL_TYPE
     void writeEntry( const QString &key, bool b );
 #endif
     void writeEntry( const QString &key, const QStringList &lst, const QChar &sep );
+    QTOPIA_MERGED_METHOD(void writeEntry( const QString &key, const QStringList &lst ), "2.1.0");
+
     void removeEntry( const QString &key );
 
     QString readEntry( const QString &key, const QString &deflt = QString::null ) const;
     QString readEntryCrypt( const QString &key, const QString &deflt = QString::null ) const;
     QString readEntryDirect( const QString &key, const QString &deflt = QString::null ) const;
     int readNumEntry( const QString &key, int deflt = -1 ) const;
     bool readBoolEntry( const QString &key, bool deflt = FALSE ) const;
     QStringList readListEntry( const QString &key, const QChar &sep ) const;
+    QTOPIA_MERGED_METHOD(QStringList readListEntry( const QString &key ) const, "2.1.0");
 
     // For compatibility, non-const versions.
     QString readEntry( const QString &key, const QString &deflt );
     QString readEntryCrypt( const QString &key, const QString &deflt );
     QString readEntryDirect( const QString &key, const QString &deflt );
     int readNumEntry( const QString &key, int deflt );
     bool readBoolEntry( const QString &key, bool deflt );
     QStringList readListEntry( const QString &key, const QChar &sep );
 
     void clearGroup();
+    QTOPIA_MERGED_METHOD(void removeGroup(), "2.1.0");
+    QTOPIA_MERGED_METHOD(void removeGroup(const QString&), "2.1.0");
+    QTOPIA_MERGED_METHOD(QStringList allGroups() const, "2.1.0");
 
     void write( const QString &fn = QString::null );
 
 protected:
     void read();
     bool parse( const QString &line );
 
     QMap< QString, ConfigGroup > groups;
     QMap< QString, ConfigGroup >::Iterator git;
     QString filename;
     QString lang;
     QString glang;
     bool changed;
     ConfigPrivate *d;
     static QString configFilename(const QString& name, Domain);
 
 private: // Sharp ROM compatibility
     Config( const QString &name, bool what );
 };
 
-inline QString Config::readEntry( const QString &key, const QString &deflt ) const
-{ return ((Config*)this)->readEntry(key,deflt); }
-inline QString Config::readEntryCrypt( const QString &key, const QString &deflt ) const
-{ return ((Config*)this)->readEntryCrypt(key,deflt); }
-inline QString Config::readEntryDirect( const QString &key, const QString &deflt ) const
-{ return ((Config*)this)->readEntryDirect(key,deflt); }
-inline int Config::readNumEntry( const QString &key, int deflt ) const
-{ return ((Config*)this)->readNumEntry(key,deflt); }
-inline bool Config::readBoolEntry( const QString &key, bool deflt ) const
-{ return ((Config*)this)->readBoolEntry(key,deflt); }
-inline QStringList Config::readListEntry( const QString &key, const QChar &sep ) const
-{ return ((Config*)this)->readListEntry(key,sep); }
-
 #endif
diff --git a/library/qpeglobal.h b/library/qpeglobal.h
index a84e435..f64ccfd 100644
--- a/library/qpeglobal.h
+++ b/library/qpeglobal.h
@@ -1,88 +1,91 @@
 /*
                              This file is part of the OPIE Project
 			     Copyright (c)  2002,2003,2004 Holger Hans Peter Freyther <freyther@handhelds.org>
 			     Copyright (c)  2002,2003,2004 Stefan Eilers <eilers@handhelds.org>
 
                =.
              .=l.
            .>+-=
  _;:,     .>    :=|.         This library is free software; you can 
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This library is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef QPE_GLOBAL_DEFINES_H
 #define QPE_GLOBAL_DEFINES_H
 
 /**
  * Defines for used compiler attributes
  *
  */
 
 /*
  * commons
  */
 #define QPE_DEPRECATED
 
 
 #if defined(Q_OS_MACX)
 #define QPE_WEAK_SYMBOL __attribute__((weak_import))
 #define QPE_SYMBOL_USED
 #define QPE_SYMBOL_UNUSED
 #define QPE_EXPORT_SYMBOL
 
 #elif defined(_OS_UNIX_)
 #define QPE_WEAK_SYMBOL  __attribute__((weak))
 #define QPE_SYMBOL_USED __attribute__((used))
 #define QPE_SYMBOL_UNUSED __attribute__((unused))
 #define QPE_EXPORT_SYMBOL
 
 
 /*
  * mark method as deprecated
  */
 #if __GNUC__ - 0 > 3 || (__GNUC__ - 0 == 3 && __GNUC_MINOR__ - 0 >= 2)
   /* gcc >= 3.2 */
 #undef  QPE_DEPRECATED
 #define QPE_DEPRECATED __attribute__((deprecated))
 #endif
 
 /*
  * Defined if Compiler supports attributes
  */
 #ifdef GCC_SUPPORTS_VISIBILITY
 #undef QPE_EXPORT_SYMBOL
 #define QPE_EXPORT_SYMBOL __attribute__((visibility("default")))
 #endif
 
 
 
 #else // defined(Q_OS_WIN32)
 #define QPE_WEAK_SYMBOL
 #define QPE_SYMBOL_USED
 #define QPE_SYMBOL_UNUSED
 #define QPE_EXPORT_SYMBOL
 #endif
 
 
+#define QTOPIA_MERGED_METHOD(method, version) method QPE_WEAK_SYMBOL;
+#define NOT_IN_SHARP(method) method QPE_WEAK_SYMBOL;
+#define NOT_IN_QPE(method) method QPE_WEAK_SYMBOL;
 
 #endif