qsettings.cpp

Go to the documentation of this file.

/****************************************************************************
** 
**
** Implementation of QSettings class
**
** Created : 000626
**
** Copyright (C) 2000-2003 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** 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.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** 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/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** 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 "qplatformdefs.h"

// POSIX Large File Support redefines open -> open64
static inline int qt_open( const char *pathname, int flags, mode_t mode )
{ return ::open( pathname, flags, mode ); }
#if defined(open)
# undef open
#endif

// POSIX Large File Support redefines truncate -> truncate64
#if defined(truncate)
# undef truncate
#endif

#include "qsettings.h"

#ifndef QT_NO_SETTINGS

#include "qdir.h"
#include "qfile.h"
#include "qfileinfo.h"
#include "qmap.h"
#include "qtextstream.h"
#include "qregexp.h"
#include <private/qsettings_p.h>
#ifndef NO_ERRNO_H
#include <errno.h>
#endif

#if defined(Q_OS_UNIX)
typedef int HANDLE;
#define Q_LOCKREAD F_RDLCK
#define Q_LOCKWRITE F_WRLCK
/*
  Locks the file specified by name.  The lockfile is created as a
  hidden file in the same directory as the target file, with .lock
  appended to the name. For example, "/etc/settings/onerc" uses a
  lockfile named "/etc/settings/.onerc.lock".  The type argument
  controls the type of the lock, it can be either F_RDLCK for a read
  lock, or F_WRLCK for a write lock.

  A file descriptor for the lock file is returned, and should be
  closed with closelock() when the lock is no longer needed.
 */
static HANDLE openlock( const QString &name, int type )
{
    QFileInfo info( name );
    // lockfile should be hidden, and never removed
    QString lockfile = info.dirPath() + "/." + info.fileName() + ".lock";

    // open the lockfile
    HANDLE fd = qt_open( QFile::encodeName( lockfile ),
                         O_RDWR | O_CREAT, S_IRUSR | S_IWUSR );

    if ( fd < 0 ) {
        // failed to open the lock file, most likely because of permissions
        return fd;
    }

    struct flock fl;
    fl.l_type = type;
    fl.l_whence = SEEK_SET;
    fl.l_start = 0;
    fl.l_len = 0;
    if ( fcntl( fd, F_SETLKW, &fl ) == -1 ) {
        // the lock failed, so we should fail silently, so that people
        // using filesystems that do not support locking don't see
        // numerous warnings about a failed lock
        close( fd );
        fd = -1;
    }

    return fd;
}

/*
  Closes the lock file specified by fd.  fd is the file descriptor
  returned by the openlock() function.
*/
static void closelock( HANDLE fd )
{
    if ( fd < 0 ) {
        // the lock file is not open
        return;
    }

    struct flock fl;
    fl.l_type = F_UNLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = 0;
    fl.l_len = 0;
    // ignore the return value, so that the unlock fails silently
    (void) fcntl( fd, F_SETLKW, &fl );

    close( fd );
}
#endif


QSettingsGroup::QSettingsGroup()
    : modified(FALSE)
{
}




void QSettingsHeading::read(const QString &filename)
{
    if (! QFileInfo(filename).exists())
        return;

#ifndef Q_WS_WIN
    HANDLE lockfd = openlock( filename, Q_LOCKREAD );
#endif

    QFile file(filename);
    if (! file.open(IO_ReadOnly)) {
#if defined(QT_CHECK_STATE)
        qWarning("QSettings: failed to open file '%s'", filename.latin1());
#endif
        return;
    }

    git = end();

    QTextStream stream(&file);
    stream.setEncoding(QTextStream::UnicodeUTF8);
    while (! stream.atEnd())
        parseLine(stream);

    git = end();

    file.close();

#ifndef Q_WS_WIN
    closelock( lockfd );
#endif
}


void QSettingsHeading::parseLine(QTextStream &stream)
{
    QString line = stream.readLine();
    if (line.isEmpty())
        // empty line... we'll allow it
        return;

    if (line[0] == QChar('#'))
        // commented line
        return;

    if (line[0] == QChar('[')) {
        QString gname = line;

        gname = gname.remove((uint)0, 1);
        if (gname[(int)gname.length() - 1] == QChar(']'))
            gname = gname.remove(gname.length() - 1, 1);

        git = find(gname);
        if (git == end())
            git = replace(gname, QSettingsGroup());
    } else {
        if (git == end()) {
#if defined(QT_CHECK_STATE)
            qWarning("QSettings: line '%s' out of group", line.latin1());
#endif
            return;
        }

        int i = line.find('=');
        if (i == -1) {
#if defined(QT_CHECK_STATE)
            qWarning("QSettings: malformed line '%s' in group '%s'",
                     line.latin1(), git.key().latin1());
#endif
            return;
        } else {
            QString key, value;
            key = line.left(i);
            value = "";
            bool esc=TRUE;
            i++;
            while (esc) {
                esc = FALSE;
                for ( ; i < (int)line.length(); i++ ) {
                    if ( esc ) {
                        if ( line[i] == 'n' )
                            value.append('\n'); // escaped newline
                        else if ( line[i] == '0' )
                            value = QString::null; // escaped empty string
                        else
                            value.append(line[i]);
                        esc = FALSE;
                    } else if ( line[i] == '\\' )
                        esc = TRUE;
                    else
                        value.append(line[i]);
                }
                if ( esc ) {
                    // Backwards-compatiblity...
                    // still escaped at EOL - manually escaped "newline"
                    if (stream.atEnd()) {
#if defined(QT_CHECK_STATE)
                        qWarning("QSettings: reached end of file, expected continued line");
#endif
                        break;
                    }
                    value.append('\n');
                    line = stream.readLine();
                    i = 0;
                }
            }

            (*git).insert(key, value);
        }
    }
}

#ifdef Q_WS_WIN // for homedirpath reading from registry
#include "qt_windows.h"
#include "qlibrary.h"

#ifndef CSIDL_APPDATA
#define CSIDL_APPDATA                   0x001a        // <user name>\Application Data
#endif
#ifndef CSIDL_COMMON_APPDATA
#define CSIDL_COMMON_APPDATA            0x0023        // All Users\Application Data
#endif

#endif

QSettingsPrivate::QSettingsPrivate( QSettings::Format format )
    : groupDirty( TRUE ), modified(FALSE), globalScope(TRUE)
{
#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( format != QSettings::Ini )
        return;
#else
    Q_UNUSED( format );
#endif

    QString appSettings(QDir::homeDirPath() + "/.qt/");
    QString defPath;
#ifdef Q_WS_WIN
#ifdef Q_OS_TEMP
        TCHAR path[MAX_PATH];
        SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
        appSettings  = QString::fromUcs2( path );
        SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
        defPath = QString::fromUcs2( path );
#else
    QLibrary library( "shell32" );
    library.setAutoUnload( FALSE );
    QT_WA( {
        typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
        GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve( "SHGetSpecialFolderPathW" );
        if ( SHGetSpecialFolderPath ) {
            TCHAR path[MAX_PATH];
            SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
            appSettings  = QString::fromUcs2( (ushort*)path );
            SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
            defPath = QString::fromUcs2( (ushort*)path );
        }
    } , {
        typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, char*, int, BOOL);
        GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve( "SHGetSpecialFolderPathA" );
        if ( SHGetSpecialFolderPath ) {
            char path[MAX_PATH];
            SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
            appSettings = QString::fromLocal8Bit( path );
            SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
            defPath = QString::fromLocal8Bit( path );
        }
    } );
#endif // Q_OS_TEMP
#else
    defPath = qInstallPathSysconf();
#endif
    QDir dir(appSettings);
    if (! dir.exists()) {
        if (! dir.mkdir(dir.path()))
#if defined(QT_CHECK_STATE)
            qWarning("QSettings: error creating %s", dir.path().latin1());
#else
            ;
#endif
    }

    if ( !!defPath )
        searchPaths.append(defPath);
    searchPaths.append(dir.path());
}

QSettingsPrivate::~QSettingsPrivate()
{
}

QSettingsGroup QSettingsPrivate::readGroup()
{
    QSettingsHeading hd;
    QSettingsGroup grp;

    QMap<QString,QSettingsHeading>::Iterator headingsit = headings.find(heading);
    if (headingsit != headings.end())
        hd = *headingsit;

    QSettingsHeading::Iterator grpit = hd.find(group);
    if (grpit == hd.end()) {
        QStringList::Iterator it = searchPaths.begin();
        if ( !globalScope )
            ++it;
        while (it != searchPaths.end()) {
            QString filebase = heading.lower().replace(QRegExp("\\s+"), "_");
            QString fn((*it++) + "/" + filebase + "rc");
            if (! hd.contains(fn + "cached")) {
                hd.read(fn);
                hd.insert(fn + "cached", QSettingsGroup());
            }
        }

        headings.replace(heading, hd);

        grpit = hd.find(group);
        if (grpit != hd.end())
            grp = *grpit;
    } else if (hd.count() != 0)
        grp = *grpit;

    return grp;
}


void QSettingsPrivate::removeGroup(const QString &key)
{
    QSettingsHeading hd;
    QSettingsGroup grp;
    bool found = FALSE;

    QMap<QString,QSettingsHeading>::Iterator headingsit = headings.find(heading);
    if (headingsit != headings.end())
        hd = *headingsit;

    QSettingsHeading::Iterator grpit = hd.find(group);
    if (grpit == hd.end()) {
        QStringList::Iterator it = searchPaths.begin();
        if ( !globalScope )
            ++it;
        while (it != searchPaths.end()) {
            QString filebase = heading.lower().replace(QRegExp("\\s+"), "_");
            QString fn((*it++) + "/" + filebase + "rc");
            if (! hd.contains(fn + "cached")) {
                hd.read(fn);
                hd.insert(fn + "cached", QSettingsGroup());
            }
        }

        headings.replace(heading, hd);

        grpit = hd.find(group);
        if (grpit != hd.end()) {
            found = TRUE;
            grp = *grpit;
        }
    } else if (hd.count() != 0) {
        found = TRUE;
        grp = *grpit;
    }

    if (found) {
        grp.remove(key);

        if (grp.count() > 0)
            hd.replace(group, grp);
        else
            hd.remove(group);

        if (hd.count() > 0)
            headings.replace(heading, hd);
        else
            headings.remove(heading);

        modified = TRUE;
    }
}


void QSettingsPrivate::writeGroup(const QString &key, const QString &value)
{
    QSettingsHeading hd;
    QSettingsGroup grp;

    QMap<QString,QSettingsHeading>::Iterator headingsit = headings.find(heading);
    if (headingsit != headings.end())
        hd = *headingsit;

    QSettingsHeading::Iterator grpit = hd.find(group);
    if (grpit == hd.end()) {
        QStringList::Iterator it = searchPaths.begin();
        if ( !globalScope )
            ++it;
        while (it != searchPaths.end()) {
            QString filebase = heading.lower().replace(QRegExp("\\s+"), "_");
            QString fn((*it++) + "/" + filebase + "rc");
            if (! hd.contains(fn + "cached")) {
                hd.read(fn);
                hd.insert(fn + "cached", QSettingsGroup());
            }
        }

        headings.replace(heading, hd);

        grpit = hd.find(group);
        if (grpit != hd.end())
            grp = *grpit;
    } else if (hd.count() != 0)
        grp = *grpit;

    grp.modified = TRUE;
    grp.replace(key, value);
    hd.replace(group, grp);
    headings.replace(heading, hd);

    modified = TRUE;
}


QDateTime QSettingsPrivate::modificationTime()
{
    QSettingsHeading hd = headings[heading];
    QSettingsGroup grp = hd[group];

    QDateTime datetime;

    QStringList::Iterator it = searchPaths.begin();
    if ( !globalScope )
        ++it;
    while (it != searchPaths.end()) {
        QFileInfo fi((*it++) + "/" + heading + "rc");
        if (fi.exists() && fi.lastModified() > datetime)
            datetime = fi.lastModified();
    }

    return datetime;
}

bool qt_verify_key( const QString &key )
{
    if ( key.isEmpty() || key[0] != '/' || key.contains( QRegExp("[=\\r\\n]" ) ) )
        return FALSE;
    return TRUE;
}

static QString groupKey( const QString &group, const QString &key )
{
    QString grp_key;
    if ( group.isEmpty() || ( group.length() == 1 && group[0] == '/' ) ) {
        // group is empty, or it contains a single '/', so we just return the key
        if ( key.startsWith( "/" ) )
            grp_key = key;
        else
            grp_key = "/" + key;
    } else if ( group.endsWith( "/" ) || key.startsWith( "/" ) ) {
        grp_key = group + key;
    } else {
        grp_key = group + "/" + key;
    }
    return grp_key;
}

void QSettings::insertSearchPath( System s, const QString &path)
{
#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd ) {
        d->sysInsertSearchPath( s, path );
        return;
    }
#endif

#if !defined(Q_WS_WIN)
    if ( s == Windows )
        return;
#endif
#if !defined(Q_OS_MAC)
    if ( s == Mac )
        return;
#endif

    if ( !qt_verify_key( path ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() );
#endif
        return;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd && s != Unix ) {
#else
    if ( s != Unix ) {
#endif
#if !defined(QWS) && defined(Q_OS_MAC)
        if(s != Mac) //mac is respected on the mac as well
#endif
            return;
    }

    QString realPath = path;
#if defined(Q_WS_WIN)
    QString defPath = d->globalScope ? d->searchPaths.first() : d->searchPaths.last();
    realPath = defPath + path;
#endif

    QStringList::Iterator it = d->searchPaths.find(d->searchPaths.last());
    if (it != d->searchPaths.end()) {
        d->searchPaths.insert(it, realPath);
    }
}


void QSettings::removeSearchPath( System s, const QString &path)
{
    if ( !qt_verify_key( path ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() );
#endif
        return;
    }

#ifdef Q_WS_WIN
    if ( d->sysd ) {
        d->sysRemoveSearchPath( s, path );
        return;
    }
#endif
#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd && s != Unix ) {
#else
    if ( s != Unix ) {
#endif
#if !defined(QWS) && defined(Q_OS_MAC)
        if(s != Mac) //mac is respected on the mac as well
#endif
            return;
    }

    if (path == d->searchPaths.first() || path == d->searchPaths.last())
        return;

    d->searchPaths.remove(path);
}


QSettings::QSettings()
{
    d = new QSettingsPrivate( Native );
    Q_CHECK_PTR(d);

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    d->sysd = 0;
    d->sysInit();
#endif
}

QSettings::QSettings( Format format )
{
    d = new QSettingsPrivate( format );
    Q_CHECK_PTR(d);

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    d->sysd = 0;
    if ( format == Native )
        d->sysInit();
#else
    Q_UNUSED(format);
#endif
}

QSettings::~QSettings()
{
    sync();

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        d->sysClear();
#endif

    delete d;
}


bool QSettings::sync()
{
#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysSync();
#endif
    if (! d->modified)
        // fake success
        return TRUE;

    bool success = TRUE;
    QMap<QString,QSettingsHeading>::Iterator it = d->headings.begin();

    while (it != d->headings.end()) {
        // determine filename
        QSettingsHeading hd(*it);
        QSettingsHeading::Iterator hdit = hd.begin();
        QString filename;

        QStringList::Iterator pit = d->searchPaths.begin();
        if ( !d->globalScope )
            ++pit;
        while (pit != d->searchPaths.end()) {
            QString filebase = it.key().lower().replace(QRegExp("\\s+"), "_");
            QFileInfo di(*pit);
            if ( !di.exists() ) {
                QDir dir;
                dir.mkdir( *pit );
            }

            QFileInfo fi((*pit++) + "/" + filebase + "rc");

            if ((fi.exists() && fi.isFile() && fi.isWritable()) ||
                (! fi.exists() && di.isDir() 
#ifndef Q_WS_WIN
                && di.isWritable()
#else
                && ((qWinVersion()&Qt::WV_NT_based) > Qt::WV_2000 || di.isWritable())
#endif
                )) {
                filename = fi.filePath();
                break;
            }
        }

        ++it;

        if ( filename.isEmpty() ) {

#ifdef QT_CHECK_STATE
            qWarning("QSettings::sync: filename is null/empty");
#endif // QT_CHECK_STATE

            success = FALSE;
            continue;
        }

#ifndef Q_WS_WIN
        HANDLE lockfd = openlock( filename, Q_LOCKWRITE );
#endif

        QFile file( filename + ".tmp" );
        if (! file.open(IO_WriteOnly)) {

#ifdef QT_CHECK_STATE
            qWarning("QSettings::sync: failed to open '%s' for writing",
                     file.name().latin1());
#endif // QT_CHECK_STATE

            success = FALSE;
            continue;
        }

        // spew to file
        QTextStream stream(&file);
        stream.setEncoding(QTextStream::UnicodeUTF8);

        while (hdit != hd.end()) {
            if ((*hdit).count() > 0) {
                stream << "[" << hdit.key() << "]" << endl;

                QSettingsGroup grp(*hdit);
                QSettingsGroup::Iterator grpit = grp.begin();

                while (grpit != grp.end()) {
                    QString v = grpit.data();
                    if ( v.isNull() ) {
                        v = "\\0"; // escape null string
                    } else {
                        v.replace("\\", "\\\\"); // escape backslash
                        v.replace("\n", "\\n"); // escape newlines
                    }

                    stream << grpit.key() << "=" << v << endl;
                    ++grpit;
                }

                stream << endl;
            }

            ++hdit;
        }

        if (file.status() != IO_Ok) {

#ifdef QT_CHECK_STATE
            qWarning("QSettings::sync: error at end of write");
#endif // QT_CHECK_STATE

            success = FALSE;
        }

        file.close();

        if ( success ) {
            QDir dir( QFileInfo( file ).dir( TRUE ) );
            if ( dir.exists( filename ) && !dir.remove( filename ) ||
                 !dir.rename( file.name(), filename, TRUE ) ) {

#ifdef QT_CHECK_STATE
                qWarning( "QSettings::sync: error writing file '%s'",
                          QFile::encodeName( filename ).data() );
#endif // QT_CHECK_STATE

                success = FALSE;
            }
        }

        // remove temporary file
        file.remove();

#ifndef Q_WS_WIN
        closelock( lockfd );
#endif
    }

    d->modified = FALSE;

    return success;
}


bool QSettings::readBoolEntry(const QString &key, bool def, bool *ok )
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::readBoolEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        if ( ok )
            *ok = FALSE;

        return def;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysReadBoolEntry( grp_key, def, ok );
#endif

    QString value = readEntry( key, ( def ? "true" : "false" ), ok );

    if (value.lower() == "true")
        return TRUE;
    else if (value.lower() == "false")
        return FALSE;
    else if (value == "1")
        return TRUE;
    else if (value == "0")
        return FALSE;

    if (! value.isEmpty())
        qWarning("QSettings::readBoolEntry: '%s' is not 'true' or 'false'",
                 value.latin1());
    if ( ok )
        *ok = FALSE;
    return def;
}


double QSettings::readDoubleEntry(const QString &key, double def, bool *ok )
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::readDoubleEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        if ( ok )
            *ok = FALSE;

        return def;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysReadDoubleEntry( grp_key, def, ok );
#endif

    QString value = readEntry( key, QString::number(def), ok );
    bool conv_ok;
    double retval = value.toDouble( &conv_ok );
    if ( conv_ok )
        return retval;
    if ( ! value.isEmpty() )
        qWarning( "QSettings::readDoubleEntry: '%s' is not a number",
                  value.latin1() );
    if ( ok )
        *ok = FALSE;
    return def;
}


int QSettings::readNumEntry(const QString &key, int def, bool *ok )
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::readNumEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        if ( ok )
            *ok = FALSE;
        return def;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysReadNumEntry( grp_key, def, ok );
#endif

    QString value = readEntry( key, QString::number( def ), ok );
    bool conv_ok;
    int retval = value.toInt( &conv_ok );
    if ( conv_ok )
        return retval;
    if ( ! value.isEmpty() )
        qWarning( "QSettings::readNumEntry: '%s' is not a number",
                  value.latin1() );
    if ( ok )
        *ok = FALSE;
    return def;
}


QString QSettings::readEntry(const QString &key, const QString &def, bool *ok )
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::readEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        if ( ok )
            *ok = FALSE;

        return def;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysReadEntry( grp_key, def, ok );
#endif

    if ( ok ) // no, everything is not ok
        *ok = FALSE;

    QString realkey;

    if (grp_key[0] == '/') {
        // parse our key
        QStringList list(QStringList::split('/', grp_key));

        if (list.count() < 2) {
#ifdef QT_CHECK_STATE
            qWarning("QSettings::readEntry: invalid key '%s'", grp_key.latin1());
#endif // QT_CHECK_STATE
            if ( ok )
                *ok = FALSE;
            return def;
        }

        if (list.count() == 2) {
            d->heading = list[0];
            d->group = "General";
            realkey = list[1];
        } else {
            d->heading = list[0];
            d->group = list[1];

            // remove the group from the list
            list.remove(list.at(1));
            // remove the heading from the list
            list.remove(list.at(0));

            realkey = list.join("/");
        }
    } else {
        realkey = grp_key;
    }

    QSettingsGroup grp = d->readGroup();
    QSettingsGroup::const_iterator it = grp.find( realkey ), end = grp.end();
    QString retval = def;
    if ( it != end ) {
        // found the value we needed
        retval = *it;
        if ( ok ) *ok = TRUE;
    }
    return retval;
}


#if !defined(Q_NO_BOOL_TYPE)

bool QSettings::writeEntry(const QString &key, bool value)
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return FALSE;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysWriteEntry( grp_key, value );
#endif
    QString s(value ? "true" : "false");
    return writeEntry(key, s);
}
#endif


bool QSettings::writeEntry(const QString &key, double value)
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return FALSE;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysWriteEntry( grp_key, value );
#endif
    QString s(QString::number(value));
    return writeEntry(key, s);
}


bool QSettings::writeEntry(const QString &key, int value)
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return FALSE;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysWriteEntry( grp_key, value );
#endif
    QString s(QString::number(value));
    return writeEntry(key, s);
}


bool QSettings::writeEntry(const QString &key, const char *value)
{
    return writeEntry(key, QString(value));
}


bool QSettings::writeEntry(const QString &key, const QString &value)
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return FALSE;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysWriteEntry( grp_key, value );
#endif
    // NOTE: we *do* allow value to be a null/empty string

    QString realkey;

    if (grp_key[0] == '/') {
        // parse our key
        QStringList list(QStringList::split('/', grp_key));

        if (list.count() < 2) {
#ifdef QT_CHECK_STATE
            qWarning("QSettings::writeEntry: invalid key '%s'", grp_key.latin1());
#endif // QT_CHECK_STATE

            return FALSE;
        }

        if (list.count() == 2) {
            d->heading = list[0];
            d->group = "General";
            realkey = list[1];
        } else {
            d->heading = list[0];
            d->group = list[1];

            // remove the group from the list
            list.remove(list.at(1));
            // remove the heading from the list
            list.remove(list.at(0));

            realkey = list.join("/");
        }
    } else {
        realkey = grp_key;
    }

    d->writeGroup(realkey, value);
    return TRUE;
}


bool QSettings::removeEntry(const QString &key)
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::removeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return FALSE;
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysRemoveEntry( grp_key );
#endif

    QString realkey;
    if (grp_key[0] == '/') {
        // parse our key
        QStringList list(QStringList::split('/', grp_key));

        if (list.count() < 2) {
#ifdef QT_CHECK_STATE
            qWarning("QSettings::removeEntry: invalid key '%s'", grp_key.latin1());
#endif // QT_CHECK_STATE

            return FALSE;
        }

        if (list.count() == 2) {
            d->heading = list[0];
            d->group = "General";
            realkey = list[1];
        } else {
            d->heading = list[0];
            d->group = list[1];

            // remove the group from the list
            list.remove(list.at(1));
            // remove the heading from the list
            list.remove(list.at(0));

            realkey = list.join("/");
        }
    } else {
        realkey = grp_key;
    }

    d->removeGroup(realkey);
    return TRUE;
}


QStringList QSettings::entryList(const QString &key) const
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::entryList: Invalid key: %s", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return QStringList();
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysEntryList( grp_key );
#endif

    QString realkey;
    if (grp_key[0] == '/') {
        // parse our key
        QStringList list(QStringList::split('/', grp_key));

        if (list.count() < 1) {
#ifdef QT_CHECK_STATE
            qWarning("QSettings::listEntries: invalid key '%s'", grp_key.latin1());
#endif // QT_CHECK_STATE

            return QStringList();
        }

        if (list.count() == 1) {
            d->heading = list[0];
            d->group = "General";
        } else {
            d->heading = list[0];
            d->group = list[1];

            // remove the group from the list
            list.remove(list.at(1));
            // remove the heading from the list
            list.remove(list.at(0));

            realkey = list.join("/");
        }
    } else
        realkey = grp_key;

    QSettingsGroup grp = d->readGroup();
    QSettingsGroup::Iterator it = grp.begin();
    QStringList ret;
    QString itkey;
    while (it != grp.end()) {
        itkey = it.key();
        ++it;

        if ( realkey.length() > 0 ) {
            if ( itkey.left( realkey.length() ) != realkey )
                continue;
            else
                itkey.remove( 0, realkey.length() + 1 );
        }

        if ( itkey.find( '/' ) != -1 )
            continue;

        ret << itkey;
    }

    return ret;
}


QStringList QSettings::subkeyList(const QString &key) const
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::subkeyList: Invalid key: %s", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return QStringList();
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return d->sysSubkeyList( grp_key );
#endif

    QString realkey;
    int subkeycount = 2;
    if (grp_key[0] == '/') {
        // parse our key
        QStringList list(QStringList::split('/', grp_key));

        if (list.count() < 1) {
#ifdef QT_CHECK_STATE
            qWarning("QSettings::subkeyList: invalid key '%s'", grp_key.latin1());
#endif // QT_CHECK_STATE

            return QStringList();
        }

        subkeycount = list.count();

        if (list.count() == 1) {
            d->heading = list[0];
            d->group = "General";
        } else {
            d->heading = list[0];
            d->group = list[1];

            // remove the group from the list
            list.remove(list.at(1));
            // remove the heading from the list
            list.remove(list.at(0));

            realkey = list.join("/");
        }

    } else
        realkey = grp_key;

    QStringList ret;
    if ( subkeycount == 1 ) {
        QMap<QString,QSettingsHeading>::Iterator it = d->headings.begin();
        while ( it != d->headings.end() ) {
            if ( it.key() != "General" && ! ret.contains( it.key() ) )
                ret << it.key();
            ++it;
        }

        return ret;
    }

    QSettingsGroup grp = d->readGroup();
    QSettingsGroup::Iterator it = grp.begin();
    QString itkey;
    while (it != grp.end()) {
        itkey = it.key();
        ++it;

        if ( realkey.length() > 0 ) {
            if ( itkey.left( realkey.length() ) != realkey )
                continue;
            else
                itkey.remove( 0, realkey.length() + 1 );
        }

        int slash = itkey.find( '/' );
        if ( slash == -1 )
            continue;
        itkey.truncate( slash );

        if ( ! ret.contains( itkey ) )
            ret << itkey;
    }

    return ret;
}


QDateTime QSettings::lastModificationTime( const QString &key )
{
    QString grp_key( groupKey( group(), key ) );
    if ( !qt_verify_key( grp_key ) ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QSettings::lastModificationTime: Invalid key '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
#endif
        return QDateTime();
    }

#if !defined(QWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC))
    if ( d->sysd )
        return QDateTime();
#endif

    if (grp_key[0] == '/') {
        // parse our key
        QStringList list(QStringList::split('/', grp_key));

        if (list.count() < 2) {
#ifdef QT_CHECK_STATE
            qWarning("QSettings::lastModificationTime: Invalid key '%s'", grp_key.latin1());
#endif // QT_CHECK_STATE

            return QDateTime();
        }

        if (list.count() == 2) {
            d->heading = list[0];
            d->group = "General";
        } else {
            d->heading = list[0];
            d->group = list[1];
        }
    }

    return d->modificationTime();
}


bool QSettings::writeEntry(const QString &key, const QStringList &value,
                           const QChar &separator)
{
    QString s(value.join(separator));
    return writeEntry(key, s);
}

bool QSettings::writeEntry(const QString &key, const QStringList &value)
{
    QString s;
    for (QStringList::ConstIterator it=value.begin(); it!=value.end(); ++it) {
        QString el = *it;
        if ( el.isNull() ) {
            el = "^0";
        } else {
            el.replace("^", "^^");
        }
        s+=el;
        s+="^e"; // end of element
    }
    return writeEntry(key, s);
}


QStringList QSettings::readListEntry(const QString &key, const QChar &separator, bool *ok )
{
    QString value = readEntry( key, QString::null, ok );
    if ( ok && !*ok )
        return QStringList();

    return QStringList::split(separator, value);
}

QStringList QSettings::readListEntry(const QString &key, bool *ok )
{
    QString value = readEntry( key, QString::null, ok );
    if ( ok && !*ok )
        return QStringList();
    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;
}

#ifdef Q_OS_MAC
void qt_setSettingsBasePath(const QString &); //qsettings_mac.cpp
#endif

void QSettings::setPath( const QString &domain, const QString &product, Scope scope )
{
//    On Windows, any trailing ".com(\..*)" is stripped from the domain. The
//    Global scope corresponds to HKEY_LOCAL_MACHINE, and User corresponds to
//    HKEY_CURRENT_USER. Note that on some installations, not all users can
//    write to the Global scope. On UNIX, any trailing ".com(\..*)" is stripped
//    from the domain. The Global scope corresponds to "/opt" (this would be
//    configurable at library build time - eg. to "/usr/local" or "/usr"),
//    while the User scope corresponds to $HOME/.*rc.
//    Note that on most installations, not all users can write to the System
//    scope.
//
//    On MacOS X, if there is no "." in domain, append ".com", then reverse the
//    order of the elements (Mac OS uses "com.apple.finder" as domain+product).
//    The Global scope corresponds to /Library/Preferences/*.plist, while the
//    User scope corresponds to ~/Library/Preferences/*.plist.
//    Note that on most installations, not all users can write to the System
//    scope.
    d->globalScope = scope == Global;

    QString actualSearchPath;
    int lastDot = domain.findRev( '.' );

#if defined(Q_WS_WIN)
    actualSearchPath = "/" + domain.mid( 0, lastDot ) + "/" + product;
    insertSearchPath( Windows, actualSearchPath );
#elif !defined(QWS) && defined(Q_OS_MAC)
    if(lastDot != -1) {
        QString topLevelDomain = domain.right( domain.length() - lastDot - 1 ) + ".";
        if ( !topLevelDomain.isEmpty() )
            qt_setSettingsBasePath( topLevelDomain );
    }
    actualSearchPath = "/" + domain.left( lastDot ) + "." + product;
    insertSearchPath( Mac, actualSearchPath );
#else
    if (scope == User)
        actualSearchPath = QDir::homeDirPath() + "/.";
    else
        actualSearchPath = QString(qInstallPathSysconf()) + "/";
    actualSearchPath += domain.mid( 0, lastDot ) + "/" + product;
    insertSearchPath( Unix, actualSearchPath );
#endif
}

void QSettings::beginGroup( const QString &group )
{
    d->groupStack.push( group );
    d->groupDirty = TRUE;
}

void QSettings::endGroup()
{
    d->groupStack.pop();
    d->groupDirty = TRUE;
}

void QSettings::resetGroup()
{
    d->groupStack.clear();
    d->groupDirty = FALSE;
    d->groupPrefix = QString::null;
}

QString QSettings::group() const
{
    if ( d->groupDirty ) {
        d->groupDirty = FALSE;
        d->groupPrefix = QString::null;

        QValueStack<QString>::Iterator it = d->groupStack.begin();
        while ( it != d->groupStack.end() ) {
            QString group = *it;
            ++it;
            if ( group[0] != '/' )
                group.prepend( "/" );
            d->groupPrefix += group;
        }
    }
    return d->groupPrefix;
}

#endif

---