diff options
Diffstat (limited to 'src/tools/qsettings.cpp')
| -rw-r--r-- | src/tools/qsettings.cpp | 2105 |
1 files changed, 2105 insertions, 0 deletions
diff --git a/src/tools/qsettings.cpp b/src/tools/qsettings.cpp new file mode 100644 index 000000000..d7043e4bb --- /dev/null +++ b/src/tools/qsettings.cpp @@ -0,0 +1,2105 @@ +/**************************************************************************** +** +** Implementation of TQSettings class +** +** Created : 000626 +** +** Copyright (C) 2000-2008 Trolltech ASA. All rights reserved. +** +** This file is part of the tools module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing retquirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#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 + +/*! + \class TQSettings + \brief The TQSettings class provides persistent platform-independent application settings. + + \ingroup io + \ingroup misc + \mainclass + + On Unix systems, TQSettings uses text files to store settings. On Windows + systems, TQSettings uses the system registry. On Mac OS X, TQSettings uses + the Carbon preferences API. + + Each setting comprises an identifying key and the data associated with + the key. A key is a unicode string which consists of \e two or more + subkeys. A subkey is a slash, '/', followed by one or more unicode + characters (excluding slashes, newlines, carriage returns and equals, + '=', signs). The associated data, called the entry or value, may be a + boolean, an integer, a double, a string or a list of strings. Entry + strings may contain any unicode characters. + + If you want to save and restore the entire desktop's settings, i.e. + which applications are running, use TQSettings to save the settings + for each individual application and TQSessionManager to save the + desktop's session. + + Example settings: + \code + /MyCompany/MyApplication/background color + /MyCompany/MyApplication/foreground color + /MyCompany/MyApplication/geometry/x + /MyCompany/MyApplication/geometry/y + /MyCompany/MyApplication/geometry/width + /MyCompany/MyApplication/geometry/height + /MyCompany/MyApplication/recent files/1 + /MyCompany/MyApplication/recent files/2 + /MyCompany/MyApplication/recent files/3 + \endcode + Each line above is a complete key, made up of subkeys. + + A typical usage pattern for reading settings at application + startup: + \code + TQSettings settings; + settings.setPath( "MyCompany.com", "MyApplication" ); + + TQString bgColor = settings.readEntry( "/colors/background", "white" ); + int width = settings.readNumEntry( "/geometry/width", 640 ); + // ... + \endcode + + A typical usage pattern for saving settings at application exit or + 'save preferences': + \code + TQSettings settings; + settings.setPath( "MyCompany.com", "MyApplication" ); + + settings.writeEntry( "/colors/background", bgColor ); + settings.writeEntry( "/geometry/width", width ); + // ... + \endcode + + A key prefix can be prepended to all keys using beginGroup(). The + application of the prefix is stopped using endGroup(). For + example: + \code + TQSettings settings; + + settings.beginGroup( "/MainWindow" ); + settings.beginGroup( "/Geometry" ); + int x = settings.readEntry( "/x" ); + // ... + settings.endGroup(); + settings.beginGroup( "/Toolbars" ); + // ... + settings.endGroup(); + settings.endGroup(); + \endcode + + You can get a list of entry-holding keys by calling entryList(), and + a list of key-holding keys using subkeyList(). + + \code + TQStringList keys = settings.entryList( "/MyApplication" ); + // keys contains 'background color' and 'foreground color'. + + TQStringList keys = settings.entryList( "/MyApplication/recent files" ); + // keys contains '1', '2' and '3'. + + TQStringList subkeys = settings.subkeyList( "/MyApplication" ); + // subkeys contains 'geometry' and 'recent files' + + TQStringList subkeys = settings.subkeyList( "/MyApplication/recent files" ); + // subkeys is empty. + \endcode + + Since settings for Windows are stored in the registry there are + some size limitations as follows: + \list + \i A subkey may not exceed 255 characters. + \i An entry's value may not exceed 16,300 characters. + \i All the values of a key (for example, all the 'recent files' + subkeys values), may not exceed 65,535 characters. + \endlist + + These limitations are not enforced on Unix or Mac OS X. + + \warning Creating multiple, simultaneous instances of TQSettings writing + to a text file may lead to data loss! This is a known issue which will + be fixed in a future release of TQt. + + \section1 Notes for Mac OS X Applications + + The location where settings are stored is not formally defined by + the CFPreferences API. + + At the time of writing settings are stored (either on a global or + user basis, preferring locally) into a plist file in \c + $ROOT/System/Library/Preferences (in XML format). TQSettings will + create an appropriate plist file (\c{com.<first group name>.plist}) + out of the full path to a key. + + For further information on CFPreferences see + \link http://developer.apple.com/documentation/CoreFoundation/Conceptual/CFPreferences/index.html + Apple's Specifications\endlink + + \section1 Notes for Unix Applications + + There is no universally accepted place for storing application + settings under Unix. In the examples the settings file will be + searched for in the following directories: + \list 1 + \i \c SYSCONF - the default value is \c INSTALL/etc/settings + \i \c /opt/MyCompany/share/etc + \i \c /opt/MyCompany/share/MyApplication/etc + \i \c $HOME/.qt + \endlist + When reading settings the files are searched in the order shown + above, with later settings overriding earlier settings. Files for + which the user doesn't have read permission are ignored. When saving + settings TQSettings works in the order shown above, writing + to the first settings file for which the user has write permission. + (\c INSTALL is the directory where TQt was installed. This can be + modified by using the configure script's -prefix argument ) + + If you want to put the settings in a particular place in the + filesystem you could do this: + \code + settings.insertSearchPath( TQSettings::Unix, "/opt/MyCompany/share" ); + \endcode + + But in practice you may prefer not to use a search path for Unix. + For example the following code: + \code + settings.writeEntry( "/MyApplication/geometry/width", width ); + \endcode + will end up writing the "geometry/width" setting to the file + \c{$HOME/.qt/myapplicationrc} (assuming that the application is + being run by an ordinary user, i.e. not by root). + + For cross-platform applications you should ensure that the + \link #sizelimit Windows size limitations \endlink are not exceeded. + + \warning TQSettings doesn't write the settings until it is destroyed so + you should construct the TQSettings object on the stack. +*/ + +/*! + \enum TQSettings::System + + \value Mac Macintosh execution environments + \value Unix Mac OS X, Unix, Linux and Unix-like execution environments + \value Windows Windows execution environments +*/ + +/*! + \enum TQSettings::Format + + \value Native Store the settings in a platform dependent location + \value Ini Store the settings in a text file +*/ + +/*! + \enum TQSettings::Scope + + \value Global Save settings as global as possible + \value User Save settings in user space +*/ + +#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 TQString &name, int type ) +{ + TQFileInfo info( name ); + // lockfile should be hidden, and never removed + TQString lockfile = info.dirPath() + "/." + info.fileName() + ".lock"; + + // open the lockfile + HANDLE fd = qt_open( TQFile::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 + + +TQSettingsGroup::TQSettingsGroup() + : modified(FALSE) +{ +} + + + + +void TQSettingsHeading::read(const TQString &filename) +{ + if (! TQFileInfo(filename).exists()) + return; + +#ifndef Q_WS_WIN + HANDLE lockfd = openlock( filename, Q_LOCKREAD ); +#endif + + TQFile file(filename); + if (! file.open(IO_ReadOnly)) { +#if defined(QT_CHECK_STATE) + qWarning("TQSettings: failed to open file '%s'", filename.latin1()); +#endif + return; + } + + git = end(); + + TQTextStream stream(&file); + stream.setEncoding(TQTextStream::UnicodeUTF8); + while (! stream.atEnd()) + parseLine(stream); + + git = end(); + + file.close(); + +#ifndef Q_WS_WIN + closelock( lockfd ); +#endif +} + + +void TQSettingsHeading::parseLine(TQTextStream &stream) +{ + TQString line = stream.readLine(); + if (line.isEmpty()) + // empty line... we'll allow it + return; + + if (line[0] == TQChar('#')) + // commented line + return; + + if (line[0] == TQChar('[')) { + TQString gname = line; + + gname = gname.remove((uint)0, 1); + if (gname[(int)gname.length() - 1] == TQChar(']')) + gname = gname.remove(gname.length() - 1, 1); + + git = find(gname); + if (git == end()) + git = replace(gname, TQSettingsGroup()); + } else { + if (git == end()) { +#if defined(QT_CHECK_STATE) + qWarning("TQSettings: line '%s' out of group", line.latin1()); +#endif + return; + } + + int i = line.find('='); + if (i == -1) { +#if defined(QT_CHECK_STATE) + qWarning("TQSettings: malformed line '%s' in group '%s'", + line.latin1(), git.key().latin1()); +#endif + return; + } else { + TQString 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 = TQString::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("TQSettings: 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 + +TQSettingsPrivate::TQSettingsPrivate( TQSettings::Format format ) + : groupDirty( TRUE ), modified(FALSE), globalScope(TRUE) +{ +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( format != TQSettings::Ini ) + return; +#else + Q_UNUSED( format ); +#endif + + TQString appSettings(TQDir::homeDirPath() + "/.qt/"); + TQString defPath; +#ifdef Q_WS_WIN +#ifdef Q_OS_TEMP + TCHAR path[MAX_PATH]; + SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE ); + appSettings = TQString::fromUcs2( path ); + SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE ); + defPath = TQString::fromUcs2( path ); +#else + TQLibrary 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 = TQString::fromUcs2( (ushort*)path ); + SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE ); + defPath = TQString::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 = TQString::fromLocal8Bit( path ); + SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE ); + defPath = TQString::fromLocal8Bit( path ); + } + } ); +#endif // Q_OS_TEMP +#else + defPath = qInstallPathSysconf(); +#endif + TQDir dir(appSettings); + if (! dir.exists()) { + if (! dir.mkdir(dir.path())) +#if defined(QT_CHECK_STATE) + qWarning("TQSettings: error creating %s", dir.path().latin1()); +#else + ; +#endif + } + + if ( !!defPath ) + searchPaths.append(defPath); + searchPaths.append(dir.path()); +} + +TQSettingsPrivate::~TQSettingsPrivate() +{ +} + +TQSettingsGroup TQSettingsPrivate::readGroup() +{ + TQSettingsHeading hd; + TQSettingsGroup grp; + + TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.find(heading); + if (headingsit != headings.end()) + hd = *headingsit; + + TQSettingsHeading::Iterator grpit = hd.find(group); + if (grpit == hd.end()) { + TQStringList::Iterator it = searchPaths.begin(); + if ( !globalScope ) + ++it; + while (it != searchPaths.end()) { + TQString filebase = heading.lower().replace(TQRegExp(TQString::fromLatin1("\\s+")), "_"); + TQString fn((*it++) + "/" + filebase + "rc"); + if (! hd.contains(fn + "cached")) { + hd.read(fn); + hd.insert(fn + "cached", TQSettingsGroup()); + } + } + + headings.replace(heading, hd); + + grpit = hd.find(group); + if (grpit != hd.end()) + grp = *grpit; + } else if (hd.count() != 0) + grp = *grpit; + + return grp; +} + + +void TQSettingsPrivate::removeGroup(const TQString &key) +{ + TQSettingsHeading hd; + TQSettingsGroup grp; + bool found = FALSE; + + TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.find(heading); + if (headingsit != headings.end()) + hd = *headingsit; + + TQSettingsHeading::Iterator grpit = hd.find(group); + if (grpit == hd.end()) { + TQStringList::Iterator it = searchPaths.begin(); + if ( !globalScope ) + ++it; + while (it != searchPaths.end()) { + TQString filebase = heading.lower().replace(TQRegExp(TQString::fromLatin1("\\s+")), "_"); + TQString fn((*it++) + "/" + filebase + "rc"); + if (! hd.contains(fn + "cached")) { + hd.read(fn); + hd.insert(fn + "cached", TQSettingsGroup()); + } + } + + 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 TQSettingsPrivate::writeGroup(const TQString &key, const TQString &value) +{ + TQSettingsHeading hd; + TQSettingsGroup grp; + + TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.find(heading); + if (headingsit != headings.end()) + hd = *headingsit; + + TQSettingsHeading::Iterator grpit = hd.find(group); + if (grpit == hd.end()) { + TQStringList::Iterator it = searchPaths.begin(); + if ( !globalScope ) + ++it; + while (it != searchPaths.end()) { + TQString filebase = heading.lower().replace(TQRegExp(TQString::fromLatin1("\\s+")), "_"); + TQString fn((*it++) + "/" + filebase + "rc"); + if (! hd.contains(fn + "cached")) { + hd.read(fn); + hd.insert(fn + "cached", TQSettingsGroup()); + } + } + + 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; +} + + +TQDateTime TQSettingsPrivate::modificationTime() +{ + TQSettingsHeading hd = headings[heading]; + TQSettingsGroup grp = hd[group]; + + TQDateTime datetime; + + TQStringList::Iterator it = searchPaths.begin(); + if ( !globalScope ) + ++it; + while (it != searchPaths.end()) { + TQFileInfo fi((*it++) + "/" + heading + "rc"); + if (fi.exists() && fi.lastModified() > datetime) + datetime = fi.lastModified(); + } + + return datetime; +} + +bool qt_verify_key( const TQString &key ) +{ + if ( key.isEmpty() || key[0] != '/' || key.contains( TQRegExp(TQString::fromLatin1("[=\\r\\n]")) ) ) + return FALSE; + return TRUE; +} + +static TQString groupKey( const TQString &group, const TQString &key ) +{ + TQString 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; +} + +/*! + Inserts \a path into the settings search path. The semantics of \a + path depends on the system \a s. It is usually easier and better to + use setPath() instead of this function. + + When \a s is \e Windows and the execution environment is \e not + Windows the function does nothing. Similarly when \a s is \e Unix and + the execution environment is \e not Unix the function does nothing. + + When \a s is \e Windows, and the execution environment is Windows, the + search path list will be used as the first subfolder of the "Software" + folder in the registry. + + When reading settings the folders are searched forwards from the + first folder (listed below) to the last, returning the first + settings found, and ignoring any folders for which the user doesn't + have read permission. + \list 1 + \i HKEY_CURRENT_USER/Software/MyCompany/MyApplication + \i HKEY_LOCAL_MACHINE/Software/MyCompany/MyApplication + \i HKEY_CURRENT_USER/Software/MyApplication + \i HKEY_LOCAL_MACHINE/Software/MyApplication + \endlist + + \code + TQSettings settings; + settings.insertSearchPath( TQSettings::Windows, "/MyCompany" ); + settings.writeEntry( "/MyApplication/Tip of the day", TRUE ); + \endcode + The code above will write the subkey "Tip of the day" into the \e + first of the registry folders listed below that is found and for + which the user has write permission. + \list 1 + \i HKEY_LOCAL_MACHINE/Software/MyCompany/MyApplication + \i HKEY_CURRENT_USER/Software/MyCompany/MyApplication + \i HKEY_LOCAL_MACHINE/Software/MyApplication + \i HKEY_CURRENT_USER/Software/MyApplication + \endlist + If a setting is found in the HKEY_CURRENT_USER space, this setting + is overwritten independently of write permissions in the + HKEY_LOCAL_MACHINE space. + + When \a s is \e Unix, and the execution environment is Unix, the + search path list will be used when trying to determine a suitable + filename for reading and writing settings files. By default, there are + two entries in the search path: + + \list 1 + \i \c SYSCONF - where \c SYSCONF is a directory specified when + configuring TQt; by default it is INSTALL/etc/settings. + \i \c $HOME/.qt/ - where \c $HOME is the user's home directory. + \endlist + + All insertions into the search path will go before $HOME/.qt/. + For example: + \code + TQSettings settings; + settings.insertSearchPath( TQSettings::Unix, "/opt/MyCompany/share/etc" ); + settings.insertSearchPath( TQSettings::Unix, "/opt/MyCompany/share/MyApplication/etc" ); + // ... + \endcode + Will result in a search path of: + \list 1 + \i SYSCONF + \i /opt/MyCompany/share/etc + \i /opt/MyCompany/share/MyApplication/etc + \i $HOME/.qt + \endlist + When reading settings the files are searched in the order shown + above, with later settings overriding earlier settings. Files for + which the user doesn't have read permission are ignored. When saving + settings TQSettings works in the order shown above, writing + to the first settings file for which the user has write permission. + + Note that paths in the file system are not created by this + function, so they must already exist to be useful. + + Settings under Unix are stored in files whose names are based on the + first subkey of the key (not including the search path). The algorithm + for creating names is essentially: lowercase the first subkey, replace + spaces with underscores and add 'rc', e.g. + <tt>/MyCompany/MyApplication/background color</tt> will be stored in + <tt>myapplicationrc</tt> (assuming that <tt>/MyCompany</tt> is part of + the search path). + + \sa removeSearchPath() + +*/ +void TQSettings::insertSearchPath( System s, const TQString &path) +{ +#if !defined(TQWS) && (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( "TQSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() ); +#endif + return; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd && s != Unix ) { +#else + if ( s != Unix ) { +#endif +#if !defined(TQWS) && defined(Q_OS_MAC) + if(s != Mac) //mac is respected on the mac as well +#endif + return; + } + + TQString realPath = path; +#if defined(Q_WS_WIN) + TQString defPath = d->globalScope ? d->searchPaths.first() : d->searchPaths.last(); + realPath = defPath + path; +#endif + + TQStringList::Iterator it = d->searchPaths.find(d->searchPaths.last()); + if (it != d->searchPaths.end()) { + d->searchPaths.insert(it, realPath); + } +} + + +/*! + Removes all occurrences of \a path (using exact matching) from the + settings search path for system \a s. Note that the default search + paths cannot be removed. + + \sa insertSearchPath() +*/ +void TQSettings::removeSearchPath( System s, const TQString &path) +{ + if ( !qt_verify_key( path ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::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(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd && s != Unix ) { +#else + if ( s != Unix ) { +#endif +#if !defined(TQWS) && 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); +} + + +/*! + Creates a settings object. + + Be aware that you must call setPath() or insertSearchPath() before + you can use the TQSettings object. +*/ +TQSettings::TQSettings() +{ + d = new TQSettingsPrivate( Native ); + Q_CHECK_PTR(d); + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + d->sysd = 0; + d->sysInit(); +#endif +} + +/*! + Creates a settings object. If \a format is 'Ini' the settings will + be stored in a text file, using the Unix strategy (see above). If \a format + is 'Native', the settings will be stored in a platform specific way + (ie. the Windows registry). + + Be aware that you must call setPath() or insertSearchPath() before + you can use the TQSettings object. +*/ +TQSettings::TQSettings( Format format ) +{ + d = new TQSettingsPrivate( format ); + Q_CHECK_PTR(d); + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + d->sysd = 0; + if ( format == Native ) + d->sysInit(); +#else + Q_UNUSED(format); +#endif +} + +/*! + Destroys the settings object. All modifications made to the settings + will automatically be saved. + +*/ +TQSettings::~TQSettings() +{ + sync(); + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + d->sysClear(); +#endif + + delete d; +} + + +/*! \internal + Writes all modifications to the settings to disk. If any errors are + encountered, this function returns FALSE, otherwise it will return TRUE. +*/ +bool TQSettings::sync() +{ +#if !defined(TQWS) && (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; + TQMap<TQString,TQSettingsHeading>::Iterator it = d->headings.begin(); + + while (it != d->headings.end()) { + // determine filename + TQSettingsHeading hd(*it); + TQSettingsHeading::Iterator hdit = hd.begin(); + TQString filename; + + TQStringList::Iterator pit = d->searchPaths.begin(); + if ( !d->globalScope ) + ++pit; + while (pit != d->searchPaths.end()) { + TQString filebase = it.key().lower().replace(TQRegExp(TQString::fromLatin1("\\s+")), "_"); + TQFileInfo di(*pit); + if ( !di.exists() ) { + TQDir dir; + dir.mkdir( *pit ); + } + + TQFileInfo fi((*pit++) + "/" + filebase + "rc"); + + if ((fi.exists() && fi.isFile() && fi.isWritable()) || + (! fi.exists() && di.isDir() +#ifndef Q_WS_WIN + && di.isWritable() +#else + && ((qWinVersion()&TQt::WV_NT_based) > TQt::WV_2000 || di.isWritable()) +#endif + )) { + filename = fi.filePath(); + break; + } + } + + ++it; + + if ( filename.isEmpty() ) { + +#ifdef QT_CHECK_STATE + qWarning("TQSettings::sync: filename is null/empty"); +#endif // QT_CHECK_STATE + + success = FALSE; + continue; + } + +#ifndef Q_WS_WIN + HANDLE lockfd = openlock( filename, Q_LOCKWRITE ); +#endif + + TQFile file( filename + ".tmp" ); + if (! file.open(IO_WriteOnly)) { + +#ifdef QT_CHECK_STATE + qWarning("TQSettings::sync: failed to open '%s' for writing", + file.name().latin1()); +#endif // QT_CHECK_STATE + + success = FALSE; + continue; + } + + // spew to file + TQTextStream stream(&file); + stream.setEncoding(TQTextStream::UnicodeUTF8); + + while (hdit != hd.end()) { + if ((*hdit).count() > 0) { + stream << "[" << hdit.key() << "]" << endl; + + TQSettingsGroup grp(*hdit); + TQSettingsGroup::Iterator grpit = grp.begin(); + + while (grpit != grp.end()) { + TQString v = grpit.data(); + if ( v.isNull() ) { + v = TQString::fromLatin1("\\0"); // escape null string + } else { + v.replace('\\', TQString::fromLatin1("\\\\")); // escape backslash + v.replace('\n', TQString::fromLatin1("\\n")); // escape newlines + } + + stream << grpit.key() << "=" << v << endl; + ++grpit; + } + + stream << endl; + } + + ++hdit; + } + + if (file.status() != IO_Ok) { + +#ifdef QT_CHECK_STATE + qWarning("TQSettings::sync: error at end of write"); +#endif // QT_CHECK_STATE + + success = FALSE; + } + + file.close(); + + if ( success ) { + TQDir dir( TQFileInfo( file ).dir( TRUE ) ); + if ( dir.exists( filename ) && !dir.remove( filename ) || + !dir.rename( file.name(), filename, TRUE ) ) { + +#ifdef QT_CHECK_STATE + qWarning( "TQSettings::sync: error writing file '%s'", + TQFile::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; +} + + +/*! + \fn bool TQSettings::readBoolEntry(const TQString &key, bool def, bool *ok ) const + + Reads the entry specified by \a key, and returns a bool, or the + default value, \a def, if the entry couldn't be read. + If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE + otherwise. + + \sa readEntry(), readNumEntry(), readDoubleEntry(), writeEntry(), removeEntry() +*/ + +/*! + \internal +*/ +bool TQSettings::readBoolEntry(const TQString &key, bool def, bool *ok ) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::readBoolEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + if ( ok ) + *ok = FALSE; + + return def; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysReadBoolEntry( grp_key, def, ok ); +#endif + + TQString 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("TQSettings::readBoolEntry: '%s' is not 'true' or 'false'", + value.latin1()); + if ( ok ) + *ok = FALSE; + return def; +} + + +/*! + \fn double TQSettings::readDoubleEntry(const TQString &key, double def, bool *ok ) const + + Reads the entry specified by \a key, and returns a double, or the + default value, \a def, if the entry couldn't be read. + If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE + otherwise. + + \sa readEntry(), readNumEntry(), readBoolEntry(), writeEntry(), removeEntry() +*/ + +/*! + \internal +*/ +double TQSettings::readDoubleEntry(const TQString &key, double def, bool *ok ) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::readDoubleEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + if ( ok ) + *ok = FALSE; + + return def; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysReadDoubleEntry( grp_key, def, ok ); +#endif + + TQString value = readEntry( key, TQString::number(def), ok ); + bool conv_ok; + double retval = value.toDouble( &conv_ok ); + if ( conv_ok ) + return retval; + if ( ! value.isEmpty() ) + qWarning( "TQSettings::readDoubleEntry: '%s' is not a number", + value.latin1() ); + if ( ok ) + *ok = FALSE; + return def; +} + + +/*! + \fn int TQSettings::readNumEntry(const TQString &key, int def, bool *ok ) const + + Reads the entry specified by \a key, and returns an integer, or the + default value, \a def, if the entry couldn't be read. + If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE + otherwise. + + \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry() +*/ + +/*! + \internal +*/ +int TQSettings::readNumEntry(const TQString &key, int def, bool *ok ) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::readNumEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + if ( ok ) + *ok = FALSE; + return def; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysReadNumEntry( grp_key, def, ok ); +#endif + + TQString value = readEntry( key, TQString::number( def ), ok ); + bool conv_ok; + int retval = value.toInt( &conv_ok ); + if ( conv_ok ) + return retval; + if ( ! value.isEmpty() ) + qWarning( "TQSettings::readNumEntry: '%s' is not a number", + value.latin1() ); + if ( ok ) + *ok = FALSE; + return def; +} + + +/*! + \fn TQString TQSettings::readEntry(const TQString &key, const TQString &def, bool *ok ) const + + Reads the entry specified by \a key, and returns a TQString, or the + default value, \a def, if the entry couldn't be read. + If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE + otherwise. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry() +*/ + +/*! + \internal +*/ +TQString TQSettings::readEntry(const TQString &key, const TQString &def, bool *ok ) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::readEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + if ( ok ) + *ok = FALSE; + + return def; + } + +#if !defined(TQWS) && (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; + + TQString realkey; + + if (grp_key[0] == '/') { + // parse our key + TQStringList list(TQStringList::split('/', grp_key)); + + if (list.count() < 2) { +#ifdef QT_CHECK_STATE + qWarning("TQSettings::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; + } + + TQSettingsGroup grp = d->readGroup(); + TQSettingsGroup::const_iterator it = grp.find( realkey ), end = grp.end(); + TQString retval = def; + if ( it != end ) { + // found the value we needed + retval = *it; + if ( ok ) *ok = TRUE; + } + return retval; +} + + +#if !defined(Q_NO_BOOL_TYPE) +/*! + Writes the boolean entry \a value into key \a key. The \a key is + created if it doesn't exist. Any previous value is overwritten by \a + value. + + If an error occurs the settings are left unchanged and FALSE is + returned; otherwise TRUE is returned. + + \warning On certain platforms, keys are retquired to contain at least + two components (e.g., "/foo/bar"). This limitation does not apply to + TQt 4. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry() +*/ +bool TQSettings::writeEntry(const TQString &key, bool value) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return FALSE; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysWriteEntry( grp_key, value ); +#endif + TQString s(value ? "true" : "false"); + return writeEntry(key, s); +} +#endif + + +/*! + \overload + Writes the double entry \a value into key \a key. The \a key is + created if it doesn't exist. Any previous value is overwritten by \a + value. + + If an error occurs the settings are left unchanged and FALSE is + returned; otherwise TRUE is returned. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry() +*/ +bool TQSettings::writeEntry(const TQString &key, double value) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return FALSE; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysWriteEntry( grp_key, value ); +#endif + TQString s(TQString::number(value)); + return writeEntry(key, s); +} + + +/*! + \overload + Writes the integer entry \a value into key \a key. The \a key is + created if it doesn't exist. Any previous value is overwritten by \a + value. + + If an error occurs the settings are left unchanged and FALSE is + returned; otherwise TRUE is returned. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry() +*/ +bool TQSettings::writeEntry(const TQString &key, int value) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return FALSE; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysWriteEntry( grp_key, value ); +#endif + TQString s(TQString::number(value)); + return writeEntry(key, s); +} + + +/*! + \internal + + Writes the entry specified by \a key with the string-literal \a value, + replacing any previous setting. If \a value is zero-length or null, the + entry is replaced by an empty setting. + + \e NOTE: This function is provided because some compilers use the + writeEntry (const TQString &, bool) overload for this code: + writeEntry ("/foo/bar", "baz") + + If an error occurs, this functions returns FALSE and the object is left + unchanged. + + \sa readEntry(), removeEntry() +*/ +bool TQSettings::writeEntry(const TQString &key, const char *value) +{ + return writeEntry(key, TQString(value)); +} + + +/*! + \overload + Writes the string entry \a value into key \a key. The \a key is + created if it doesn't exist. Any previous value is overwritten by \a + value. If \a value is an empty string or a null string the key's + value will be an empty string. + + If an error occurs the settings are left unchanged and FALSE is + returned; otherwise TRUE is returned. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry() +*/ +bool TQSettings::writeEntry(const TQString &key, const TQString &value) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return FALSE; + } + +#if !defined(TQWS) && (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 + + TQString realkey; + + if (grp_key[0] == '/') { + // parse our key + TQStringList list(TQStringList::split('/', grp_key)); + + if (list.count() < 2) { +#ifdef QT_CHECK_STATE + qWarning("TQSettings::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; +} + + +/*! + Removes the entry specified by \a key. + + Returns true if the entry was successfully removed; otherwise + returns false. Note that removing the last entry in any given + folder, will also remove the folder. + + \sa readEntry(), writeEntry() +*/ +bool TQSettings::removeEntry(const TQString &key) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::removeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return FALSE; + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysRemoveEntry( grp_key ); +#endif + + TQString realkey; + if (grp_key[0] == '/') { + // parse our key + TQStringList list(TQStringList::split('/', grp_key)); + + if (list.count() < 2) { +#ifdef QT_CHECK_STATE + qWarning("TQSettings::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; +} + + +/*! + Returns a list of the keys which contain entries under \a key. Does \e + not return any keys that contain subkeys. + + Example settings: + \code + /MyCompany/MyApplication/background color + /MyCompany/MyApplication/foreground color + /MyCompany/MyApplication/geometry/x + /MyCompany/MyApplication/geometry/y + /MyCompany/MyApplication/geometry/width + /MyCompany/MyApplication/geometry/height + \endcode + \code + TQStringList keys = settings.entryList( "/MyCompany/MyApplication" ); + \endcode + + In the above example, \c keys will contain 'background color' and + 'foreground color'. It will not contain 'geometry' because this key + contains subkeys not entries. + + To access the geometry values, you could either use subkeyList() + to read the keys then read each entry, or simply read each entry + directly by specifying its full key, e.g. + "/MyCompany/MyApplication/geometry/y". + + \sa subkeyList() +*/ +TQStringList TQSettings::entryList(const TQString &key) const +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::entryList: Invalid key: %s", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return TQStringList(); + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysEntryList( grp_key ); +#endif + + TQString realkey; + if (grp_key[0] == '/') { + // parse our key + TQStringList list(TQStringList::split('/', grp_key)); + + if (list.count() < 1) { +#ifdef QT_CHECK_STATE + qWarning("TQSettings::listEntries: invalid key '%s'", grp_key.latin1()); +#endif // QT_CHECK_STATE + + return TQStringList(); + } + + 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; + + TQSettingsGroup grp = d->readGroup(); + TQSettingsGroup::Iterator it = grp.begin(); + TQStringList ret; + TQString 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; +} + + +/*! + Returns a list of the keys which contain subkeys under \a key. Does \e + not return any keys that contain entries. + + Example settings: + \code + /MyCompany/MyApplication/background color + /MyCompany/MyApplication/foreground color + /MyCompany/MyApplication/geometry/x + /MyCompany/MyApplication/geometry/y + /MyCompany/MyApplication/geometry/width + /MyCompany/MyApplication/geometry/height + /MyCompany/MyApplication/recent files/1 + /MyCompany/MyApplication/recent files/2 + /MyCompany/MyApplication/recent files/3 + \endcode + \code + TQStringList keys = settings.subkeyList( "/MyCompany/MyApplication" ); + \endcode + + In the above example, \c keys will contain 'geometry' and + 'recent files'. It will not contain 'background color' or + 'foreground color' because those keys contain entries not + subkeys. To get a list of keys that contain entries rather than + subkeys use entryList() instead. + + \warning In the above example, if TQSettings is writing to an Ini file, + then a call to + \code subkeyList("/MyCompany") \endcode + will return an empty list. This happens because a key like + \code /MyCompany/MyApplication/background color \endcode + is written to the file \e{"mycompanyrc"}, under the section \e{[MyApplication]}. + This call is therefore a request to list the sections in an ini file, which + is not supported in this version of TQSettings. This is a known issue which + will be fixed in TQt-4. + + \sa entryList() +*/ +TQStringList TQSettings::subkeyList(const TQString &key) const +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::subkeyList: Invalid key: %s", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return TQStringList(); + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return d->sysSubkeyList( grp_key ); +#endif + + TQString realkey; + int subkeycount = 2; + if (grp_key[0] == '/') { + // parse our key + TQStringList list(TQStringList::split('/', grp_key)); + + if (list.count() < 1) { +#ifdef QT_CHECK_STATE + qWarning("TQSettings::subkeyList: invalid key '%s'", grp_key.latin1()); +#endif // QT_CHECK_STATE + + return TQStringList(); + } + + subkeycount = (int)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; + + TQStringList ret; + if ( subkeycount == 1 ) { + TQMap<TQString,TQSettingsHeading>::Iterator it = d->headings.begin(); + while ( it != d->headings.end() ) { + if ( it.key() != "General" && ! ret.contains( it.key() ) ) + ret << it.key(); + ++it; + } + + return ret; + } + + TQSettingsGroup grp = d->readGroup(); + TQSettingsGroup::Iterator it = grp.begin(); + TQString itkey; + while (it != grp.end()) { + itkey = it.key(); + ++it; + + if ( realkey.length() > 0 ) { + if ( itkey.left( realkey.length() ) != realkey + || itkey.length()+1 < realkey.length() + || itkey[(int)realkey.length()] != '/') + 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; +} + + +/*! + \internal + + This function returns the time of last modification for \a key. +*/ +TQDateTime TQSettings::lastModificationTime( const TQString &key ) +{ + TQString grp_key( groupKey( group(), key ) ); + if ( !qt_verify_key( grp_key ) ) { +#if defined(QT_CHECK_STATE) + qWarning( "TQSettings::lastModificationTime: Invalid key '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() ); +#endif + return TQDateTime(); + } + +#if !defined(TQWS) && (defined(Q_WS_WIN) || defined(Q_OS_MAC)) + if ( d->sysd ) + return TQDateTime(); +#endif + + if (grp_key[0] == '/') { + // parse our key + TQStringList list(TQStringList::split('/', grp_key)); + + if (list.count() < 2) { +#ifdef QT_CHECK_STATE + qWarning("TQSettings::lastModificationTime: Invalid key '%s'", grp_key.latin1()); +#endif // QT_CHECK_STATE + + return TQDateTime(); + } + + if (list.count() == 2) { + d->heading = list[0]; + d->group = "General"; + } else { + d->heading = list[0]; + d->group = list[1]; + } + } + + return d->modificationTime(); +} + + +/*! + \overload + \obsolete + + Writes the string list entry \a value into key \a key. The \a key + is created if it doesn't exist. Any previous value is overwritten + by \a value. The list is stored as a sequence of strings separated + by \a separator (using TQStringList::join()), so none of the + strings in the list should contain the separator. If the list is + empty or null the key's value will be an empty string. + + \warning The list should not contain empty or null strings, as + readListEntry() will use TQStringList::split() to recreate the + list. As the documentation states, TQStringList::split() will omit + empty strings from the list. Because of this, it is impossible to + retrieve identical list data that is stored with this function. + We recommend using the writeEntry() and readListEntry() overloads + that do not take a \a separator argument. + + + If an error occurs the settings are left unchanged and FALSE is + returned; otherwise returns TRUE. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry(), TQStringList::join() +*/ +bool TQSettings::writeEntry(const TQString &key, const TQStringList &value, + const TQChar &separator) +{ + TQString s(value.join(separator)); + return writeEntry(key, s); +} + +/*! + \overload + + Writes the string list entry \a value into key \a key. The \a key + is created if it doesn't exist. Any previous value is overwritten + by \a value. + + If an error occurs the settings are left unchanged and FALSE is + returned; otherwise returns TRUE. + + \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry() +*/ +bool TQSettings::writeEntry(const TQString &key, const TQStringList &value) +{ + TQString s; + for (TQStringList::ConstIterator it=value.begin(); it!=value.end(); ++it) { + TQString el = *it; + if ( el.isNull() ) { + el = "^0"; + } else { + el.replace("^", "^^"); + } + s+=el; + s+="^e"; // end of element + } + return writeEntry(key, s); +} + + +/*! + \overload TQStringList TQSettings::readListEntry(const TQString &key, const TQChar &separator, bool *ok ) const + \obsolete + + Reads the entry specified by \a key as a string. The \a separator + is used to create a TQStringList by calling TQStringList::split(\a + separator, entry). If \a ok is not 0: \a *ok is set to TRUE + if the key was read, otherwise \a *ok is set to FALSE. + + \warning As the documentation states, TQStringList::split() will + omit empty strings from the list. Because of this, it is + impossible to retrieve identical list data with this function. We + recommend using the readListEntry() and writeEntry() overloads + that do not take a \a separator argument. + + Note that if you want to iterate over the list, you should iterate + over a copy, e.g. + \code + TQStringList list = mySettings.readListEntry( "size", " " ); + TQStringList::Iterator it = list.begin(); + while( it != list.end() ) { + myProcessing( *it ); + ++it; + } + \endcode + + \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry(), TQStringList::split() +*/ + +/*! + \internal +*/ +TQStringList TQSettings::readListEntry(const TQString &key, const TQChar &separator, bool *ok ) +{ + TQString value = readEntry( key, TQString::null, ok ); + if ( ok && !*ok ) + return TQStringList(); + + return TQStringList::split(separator, value); +} + +/*! + \fn TQStringList TQSettings::readListEntry(const TQString &key, bool *ok ) const + Reads the entry specified by \a key as a string. If \a ok is not + 0, \a *ok is set to TRUE if the key was read, otherwise \a *ok is + set to FALSE. + + Note that if you want to iterate over the list, you should iterate + over a copy, e.g. + \code + TQStringList list = mySettings.readListEntry( "recentfiles" ); + TQStringList::Iterator it = list.begin(); + while( it != list.end() ) { + myProcessing( *it ); + ++it; + } + \endcode + + \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry(), TQStringList::split() +*/ + +/*! + \internal +*/ +TQStringList TQSettings::readListEntry(const TQString &key, bool *ok ) +{ + TQString value = readEntry( key, TQString::null, ok ); + if ( ok && !*ok ) + return TQStringList(); + TQStringList l; + TQString 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=TQString::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 TQString &); //qsettings_mac.cpp +#endif + +/*! + Insert platform-dependent paths from platform-independent information. + + The \a domain should be an Internet domain name + controlled by the producer of the software, eg. Trolltech products + use "trolltech.com". + + The \a product should be the official name of the product. + + The \a scope should be + TQSettings::User for user-specific settings, or + TQSettings::Global for system-wide settings (generally + these will be read-only to many users). + + Not all information is relevant on all systems. +*/ + +void TQSettings::setPath( const TQString &domain, const TQString &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; + + TQString actualSearchPath; + int lastDot = domain.findRev( '.' ); + +#if defined(Q_WS_WIN) + actualSearchPath = "/" + domain.mid( 0, lastDot ) + "/" + product; + insertSearchPath( Windows, actualSearchPath ); +#elif !defined(TQWS) && defined(Q_OS_MAC) + if(lastDot != -1) { + TQString 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 = TQDir::homeDirPath() + "/."; + else + actualSearchPath = TQString(qInstallPathSysconf()) + "/"; + actualSearchPath += domain.mid( 0, lastDot ) + "/" + product; + insertSearchPath( Unix, actualSearchPath ); +#endif +} + +/*! + Appends \a group to the current key prefix. + + \code + TQSettings settings; + settings.beginGroup( "/MainWindow" ); + // read values + settings.endGroup(); + \endcode +*/ +void TQSettings::beginGroup( const TQString &group ) +{ + d->groupStack.push( group ); + d->groupDirty = TRUE; +} + +/*! + Undo previous calls to beginGroup(). Note that a single beginGroup("a/b/c") is undone + by a single call to endGroup(). + + \code + TQSettings settings; + settings.beginGroup( "/MainWindow/Geometry" ); + // read values + settings.endGroup(); + \endcode +*/ +void TQSettings::endGroup() +{ + d->groupStack.pop(); + d->groupDirty = TRUE; +} + +/*! + Set the current key prefix to the empty string. +*/ +void TQSettings::resetGroup() +{ + d->groupStack.clear(); + d->groupDirty = FALSE; + d->groupPrefix = TQString::null; +} + +/*! + Returns the current key prefix, or a null string if there is no key prefix set. + + \sa beginGroup(); +*/ +TQString TQSettings::group() const +{ + if ( d->groupDirty ) { + d->groupDirty = FALSE; + d->groupPrefix = TQString::null; + + TQValueStack<TQString>::Iterator it = d->groupStack.begin(); + while ( it != d->groupStack.end() ) { + TQString group = *it; + ++it; + if ( group[0] != '/' ) + group.prepend( "/" ); + d->groupPrefix += group; + } + } + return d->groupPrefix; +} + +#endif |