qiurui
/
qtbase
mirror of https://github.com/qt/qtbase.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtbase/src/corelib/io/qsettings_win.cpp

867 lines
27 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qsettings.h"
#include "qsettings_p.h"
#include "qvector.h"
#include "qmap.h"
#include "qdebug.h"
#include <qt_windows.h>
// See "Accessing an Alternate Registry View" at:
// http://msdn.microsoft.com/en-us/library/aa384129%28VS.85%29.aspx
#ifndef KEY_WOW64_64KEY
// Access a 32-bit key from either a 32-bit or 64-bit application.
# define KEY_WOW64_64KEY 0x0100
#endif
#ifndef KEY_WOW64_32KEY
// Access a 64-bit key from either a 32-bit or 64-bit application.
# define KEY_WOW64_32KEY 0x0200
#endif
QT_BEGIN_NAMESPACE
/* Keys are stored in QStrings. If the variable name starts with 'u', this is a "user"
key, ie. "foo/bar/alpha/beta". If the variable name starts with 'r', this is a "registry"
key, ie. "\foo\bar\alpha\beta". */
/*******************************************************************************
** Some convenience functions
*/
/*
We don't use KEY_ALL_ACCESS because it gives more rights than what we
need. See task 199061.
*/
static const REGSAM registryPermissions = KEY_READ | KEY_WRITE;
static QString keyPath(const QString &rKey)
{
int idx = rKey.lastIndexOf(QLatin1Char('\\'));
if (idx == -1)
return QString();
return rKey.left(idx + 1);
}
static QString keyName(const QString &rKey)
{
int idx = rKey.lastIndexOf(QLatin1Char('\\'));
QString res;
if (idx == -1)
res = rKey;
else
res = rKey.mid(idx + 1);
if (res == QLatin1String("Default") || res == QLatin1String("."))
res = QLatin1String("");
return res;
}
static QString escapedKey(QString uKey)
{
QChar *data = uKey.data();
int l = uKey.length();
for (int i = 0; i < l; ++i) {
ushort &ucs = data[i].unicode();
if (ucs == '\\')
ucs = '/';
else if (ucs == '/')
ucs = '\\';
}
return uKey;
}
static QString unescapedKey(QString rKey)
{
return escapedKey(rKey);
}
typedef QMap<QString, QString> NameSet;
static void mergeKeySets(NameSet *dest, const NameSet &src)
{
NameSet::const_iterator it = src.constBegin();
for (; it != src.constEnd(); ++it)
dest->insert(unescapedKey(it.key()), QString());
}
static void mergeKeySets(NameSet *dest, const QStringList &src)
{
QStringList::const_iterator it = src.constBegin();
for (; it != src.constEnd(); ++it)
dest->insert(unescapedKey(*it), QString());
}
/*******************************************************************************
** Wrappers for the insane windows registry API
*/
// ### Qt 6: Use new helpers from qwinregistry.cpp (once bootstrap builds are obsolete)
// Open a key with the specified "perms".
// "access" is to explicitly use the 32- or 64-bit branch.
static HKEY openKey(HKEY parentHandle, REGSAM perms, const QString &rSubKey, REGSAM access = 0)
{
HKEY resultHandle = 0;
LONG res = RegOpenKeyEx(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()),
0, perms | access, &resultHandle);
if (res == ERROR_SUCCESS)
return resultHandle;
return 0;
}
// Open a key with the specified "perms", create it if it does not exist.
// "access" is to explicitly use the 32- or 64-bit branch.
static HKEY createOrOpenKey(HKEY parentHandle, REGSAM perms, const QString &rSubKey, REGSAM access = 0)
{
// try to open it
HKEY resultHandle = openKey(parentHandle, perms, rSubKey, access);
if (resultHandle != 0)
return resultHandle;
// try to create it
LONG res = RegCreateKeyEx(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()), 0, 0,
REG_OPTION_NON_VOLATILE, perms | access, 0, &resultHandle, 0);
if (res == ERROR_SUCCESS)
return resultHandle;
//qErrnoWarning(int(res), "QSettings: Failed to create subkey \"%ls\"",
// qUtf16Printable(rSubKey));
return 0;
}
// Open or create a key in read-write mode if possible, otherwise read-only.
// "access" is to explicitly use the 32- or 64-bit branch.
static HKEY createOrOpenKey(HKEY parentHandle, const QString &rSubKey, bool *readOnly, REGSAM access = 0)
{
// try to open or create it read/write
HKEY resultHandle = createOrOpenKey(parentHandle, registryPermissions, rSubKey, access);
if (resultHandle != 0) {
if (readOnly != 0)
*readOnly = false;
return resultHandle;
}
// try to open or create it read/only
resultHandle = createOrOpenKey(parentHandle, KEY_READ, rSubKey, access);
if (resultHandle != 0) {
if (readOnly != 0)
*readOnly = true;
return resultHandle;
}
return 0;
}
static QStringList childKeysOrGroups(HKEY parentHandle, QSettingsPrivate::ChildSpec spec)
{
QStringList result;
DWORD numKeys;
DWORD maxKeySize;
DWORD numSubgroups;
DWORD maxSubgroupSize;
// Find the number of keys and subgroups, as well as the max of their lengths.
LONG res = RegQueryInfoKey(parentHandle, 0, 0, 0, &numSubgroups, &maxSubgroupSize, 0,
&numKeys, &maxKeySize, 0, 0, 0);
if (res != ERROR_SUCCESS) {
qErrnoWarning(int(res), "QSettings: RegQueryInfoKey() failed");
return result;
}
++maxSubgroupSize;
++maxKeySize;
int n;
int m;
if (spec == QSettingsPrivate::ChildKeys) {
n = numKeys;
m = maxKeySize;
} else {
n = numSubgroups;
m = maxSubgroupSize;
}
/* The size does not include the terminating null character. */
++m;
// Get the list
QByteArray buff(m * sizeof(wchar_t), 0);
for (int i = 0; i < n; ++i) {
QString item;
DWORD l = buff.size() / sizeof(wchar_t);
if (spec == QSettingsPrivate::ChildKeys) {
res = RegEnumValue(parentHandle, i, reinterpret_cast<wchar_t *>(buff.data()), &l, 0, 0, 0, 0);
} else {
res = RegEnumKeyEx(parentHandle, i, reinterpret_cast<wchar_t *>(buff.data()), &l, 0, 0, 0, 0);
}
if (res == ERROR_SUCCESS)
item = QString::fromWCharArray((const wchar_t *)buff.constData(), l);
if (res != ERROR_SUCCESS) {
qErrnoWarning(int(res), "QSettings: RegEnumValue failed");
continue;
}
if (item.isEmpty())
item = QLatin1String(".");
result.append(item);
}
return result;
}
static void allKeys(HKEY parentHandle, const QString &rSubKey, NameSet *result, REGSAM access = 0)
{
HKEY handle = openKey(parentHandle, KEY_READ, rSubKey, access);
if (handle == 0)
return;
QStringList childKeys = childKeysOrGroups(handle, QSettingsPrivate::ChildKeys);
QStringList childGroups = childKeysOrGroups(handle, QSettingsPrivate::ChildGroups);
RegCloseKey(handle);
for (int i = 0; i < childKeys.size(); ++i) {
QString s = rSubKey;
if (!s.isEmpty())
s += QLatin1Char('\\');
s += childKeys.at(i);
result->insert(s, QString());
}
for (int i = 0; i < childGroups.size(); ++i) {
QString s = rSubKey;
if (!s.isEmpty())
s += QLatin1Char('\\');
s += childGroups.at(i);
allKeys(parentHandle, s, result, access);
}
}
static void deleteChildGroups(HKEY parentHandle, REGSAM access = 0)
{
QStringList childGroups = childKeysOrGroups(parentHandle, QSettingsPrivate::ChildGroups);
for (int i = 0; i < childGroups.size(); ++i) {
QString group = childGroups.at(i);
// delete subgroups in group
HKEY childGroupHandle = openKey(parentHandle, registryPermissions, group, access);
if (childGroupHandle == 0)
continue;
deleteChildGroups(childGroupHandle, access);
RegCloseKey(childGroupHandle);
// delete group itself
LONG res = RegDeleteKey(parentHandle, reinterpret_cast<const wchar_t *>(group.utf16()));
if (res != ERROR_SUCCESS) {
qErrnoWarning(int(res), "QSettings: RegDeleteKey failed on subkey \"%ls\"",
qUtf16Printable(group));
return;
}
}
}
/*******************************************************************************
** class RegistryKey
*/
class RegistryKey
{
public:
RegistryKey(HKEY parent_handle = 0, const QString &key = QString(), bool read_only = true, REGSAM access = 0);
QString key() const;
HKEY handle() const;
HKEY parentHandle() const;
bool readOnly() const;
void close();
private:
HKEY m_parent_handle;
mutable HKEY m_handle;
QString m_key;
mutable bool m_read_only;
REGSAM m_access;
};
RegistryKey::RegistryKey(HKEY parent_handle, const QString &key, bool read_only, REGSAM access)
: m_parent_handle(parent_handle),
m_handle(0),
m_key(key),
m_read_only(read_only),
m_access(access)
{
}
QString RegistryKey::key() const
{
return m_key;
}
HKEY RegistryKey::handle() const
{
if (m_handle != 0)
return m_handle;
if (m_read_only)
m_handle = openKey(m_parent_handle, KEY_READ, m_key, m_access);
else
m_handle = createOrOpenKey(m_parent_handle, m_key, &m_read_only, m_access);
return m_handle;
}
HKEY RegistryKey::parentHandle() const
{
return m_parent_handle;
}
bool RegistryKey::readOnly() const
{
return m_read_only;
}
void RegistryKey::close()
{
if (m_handle != 0)
RegCloseKey(m_handle);
m_handle = 0;
}
typedef QVector<RegistryKey> RegistryKeyList;
/*******************************************************************************
** class QWinSettingsPrivate
*/
class QWinSettingsPrivate : public QSettingsPrivate
{
Q_DISABLE_COPY(QWinSettingsPrivate)
public:
QWinSettingsPrivate(QSettings::Scope scope, const QString &organization,
const QString &application, REGSAM access = 0);
QWinSettingsPrivate(QString rKey, REGSAM access = 0);
~QWinSettingsPrivate() override;
void remove(const QString &uKey) override;
void set(const QString &uKey, const QVariant &value) override;
bool get(const QString &uKey, QVariant *value) const override;
QStringList children(const QString &uKey, ChildSpec spec) const override;
void clear() override;
void sync() override;
void flush() override;
bool isWritable() const override;
HKEY writeHandle() const;
bool readKey(HKEY parentHandle, const QString &rSubKey, QVariant *value) const;
QString fileName() const override;
private:
RegistryKeyList regList; // list of registry locations to search for keys
bool deleteWriteHandleOnExit;
REGSAM access;
};
QWinSettingsPrivate::QWinSettingsPrivate(QSettings::Scope scope, const QString &organization,
const QString &application, REGSAM access)
: QSettingsPrivate(QSettings::NativeFormat, scope, organization, application),
access(access)
{
deleteWriteHandleOnExit = false;
if (!organization.isEmpty()) {
QString prefix = QLatin1String("Software\\") + organization;
QString orgPrefix = prefix + QLatin1String("\\OrganizationDefaults");
QString appPrefix = prefix + QLatin1Char('\\') + application;
if (scope == QSettings::UserScope) {
if (!application.isEmpty())
regList.append(RegistryKey(HKEY_CURRENT_USER, appPrefix, !regList.isEmpty(), access));
regList.append(RegistryKey(HKEY_CURRENT_USER, orgPrefix, !regList.isEmpty(), access));
}
if (!application.isEmpty())
regList.append(RegistryKey(HKEY_LOCAL_MACHINE, appPrefix, !regList.isEmpty(), access));
regList.append(RegistryKey(HKEY_LOCAL_MACHINE, orgPrefix, !regList.isEmpty(), access));
}
if (regList.isEmpty())
setStatus(QSettings::AccessError);
}
QWinSettingsPrivate::QWinSettingsPrivate(QString rPath, REGSAM access)
: QSettingsPrivate(QSettings::NativeFormat),
access(access)
{
deleteWriteHandleOnExit = false;
if (rPath.startsWith(QLatin1Char('\\')))
rPath.remove(0, 1);
int keyLength;
HKEY keyName;
if (rPath.startsWith(QLatin1String("HKEY_CURRENT_USER"))) {
keyLength = 17;
keyName = HKEY_CURRENT_USER;
} else if (rPath.startsWith(QLatin1String("HKCU"))) {
keyLength = 4;
keyName = HKEY_CURRENT_USER;
} else if (rPath.startsWith(QLatin1String("HKEY_LOCAL_MACHINE"))) {
keyLength = 18;
keyName = HKEY_LOCAL_MACHINE;
} else if (rPath.startsWith(QLatin1String("HKLM"))) {
keyLength = 4;
keyName = HKEY_LOCAL_MACHINE;
} else if (rPath.startsWith(QLatin1String("HKEY_CLASSES_ROOT"))) {
keyLength = 17;
keyName = HKEY_CLASSES_ROOT;
} else if (rPath.startsWith(QLatin1String("HKCR"))) {
keyLength = 4;
keyName = HKEY_CLASSES_ROOT;
} else if (rPath.startsWith(QLatin1String("HKEY_USERS"))) {
keyLength = 10;
keyName = HKEY_USERS;
} else if (rPath.startsWith(QLatin1String("HKU"))) {
keyLength = 3;
keyName = HKEY_USERS;
} else {
return;
}
if (rPath.length() == keyLength)
regList.append(RegistryKey(keyName, QString(), false, access));
else if (rPath[keyLength] == QLatin1Char('\\'))
regList.append(RegistryKey(keyName, rPath.mid(keyLength+1), false, access));
}
bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVariant *value) const
{
QString rSubkeyName = keyName(rSubKey);
QString rSubkeyPath = keyPath(rSubKey);
// open a handle on the subkey
HKEY handle = openKey(parentHandle, KEY_READ, rSubkeyPath, access);
if (handle == 0)
return false;
// get the size and type of the value
DWORD dataType;
DWORD dataSize;
LONG res = RegQueryValueEx(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, &dataType, 0, &dataSize);
if (res != ERROR_SUCCESS) {
RegCloseKey(handle);
return false;
}
// workaround for rare cases where trailing '\0' are missing in registry
if (dataType == REG_SZ || dataType == REG_EXPAND_SZ)
dataSize += 2;
else if (dataType == REG_MULTI_SZ)
dataSize += 4;
// get the value
QByteArray data(dataSize, 0);
res = RegQueryValueEx(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, 0,
reinterpret_cast<unsigned char*>(data.data()), &dataSize);
if (res != ERROR_SUCCESS) {
RegCloseKey(handle);
return false;
}
switch (dataType) {
case REG_EXPAND_SZ:
case REG_SZ: {
QString s;
if (dataSize) {
s = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData()));
}
if (value != 0)
*value = stringToVariant(s);
break;
}
case REG_MULTI_SZ: {
QStringList l;
if (dataSize) {
int i = 0;
for (;;) {
QString s = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData()) + i);
i += s.length() + 1;
if (s.isEmpty())
break;
l.append(s);
}
}
if (value != 0)
*value = stringListToVariantList(l);
break;
}
case REG_NONE:
case REG_BINARY: {
QString s;
if (dataSize) {
s = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData()), data.size() / 2);
}
if (value != 0)
*value = stringToVariant(s);
break;
}
case REG_DWORD_BIG_ENDIAN:
case REG_DWORD: {
Q_ASSERT(data.size() == sizeof(int));
int i;
memcpy(reinterpret_cast<char*>(&i), data.constData(), sizeof(int));
if (value != 0)
*value = i;
break;
}
case REG_QWORD: {
Q_ASSERT(data.size() == sizeof(qint64));
qint64 i;
memcpy(reinterpret_cast<char*>(&i), data.constData(), sizeof(qint64));
if (value != 0)
*value = i;
break;
}
default:
qWarning("QSettings: Unknown data %d type in Windows registry", static_cast<int>(dataType));
if (value != 0)
*value = QVariant();
break;
}
RegCloseKey(handle);
return true;
}
HKEY QWinSettingsPrivate::writeHandle() const
{
if (regList.isEmpty())
return 0;
const RegistryKey &key = regList.at(0);
if (key.handle() == 0 || key.readOnly())
return 0;
return key.handle();
}
QWinSettingsPrivate::~QWinSettingsPrivate()
{
if (deleteWriteHandleOnExit && writeHandle() != 0) {
QString emptyKey;
DWORD res = RegDeleteKey(writeHandle(), reinterpret_cast<const wchar_t *>(emptyKey.utf16()));
if (res != ERROR_SUCCESS) {
qErrnoWarning(int(res), "QSettings: Failed to delete key \"%ls\"",
qUtf16Printable(regList.constFirst().key()));
}
}
for (int i = 0; i < regList.size(); ++i)
regList[i].close();
}
void QWinSettingsPrivate::remove(const QString &uKey)
{
if (writeHandle() == 0) {
setStatus(QSettings::AccessError);
return;
}
QString rKey = escapedKey(uKey);
// try to delete value bar in key foo
LONG res;
HKEY handle = openKey(writeHandle(), registryPermissions, keyPath(rKey), access);
if (handle != 0) {
res = RegDeleteValue(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()));
RegCloseKey(handle);
}
// try to delete key foo/bar and all subkeys
handle = openKey(writeHandle(), registryPermissions, rKey, access);
if (handle != 0) {
deleteChildGroups(handle, access);
if (rKey.isEmpty()) {
const QStringList childKeys = childKeysOrGroups(handle, QSettingsPrivate::ChildKeys);
for (const QString &group : childKeys) {
LONG res = RegDeleteValue(handle, reinterpret_cast<const wchar_t *>(group.utf16()));
if (res != ERROR_SUCCESS) {
qErrnoWarning(int(res), "QSettings: RegDeleteValue failed on subkey \"%ls\"",
qUtf16Printable(group));
}
}
} else {
res = RegDeleteKey(writeHandle(), reinterpret_cast<const wchar_t *>(rKey.utf16()));
if (res != ERROR_SUCCESS) {
qErrnoWarning(int(res), "QSettings: RegDeleteKey failed on key \"%ls\"",
qUtf16Printable(rKey));
}
}
RegCloseKey(handle);
}
}
void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value)
{
if (writeHandle() == 0) {
setStatus(QSettings::AccessError);
return;
}
QString rKey = escapedKey(uKey);
HKEY handle = createOrOpenKey(writeHandle(), registryPermissions, keyPath(rKey), access);
if (handle == 0) {
setStatus(QSettings::AccessError);
return;
}
DWORD type;
QByteArray regValueBuff;
// Determine the type
switch (value.type()) {
case QVariant::List:
case QVariant::StringList: {
// If none of the elements contains '\0', we can use REG_MULTI_SZ, the
// native registry string list type. Otherwise we use REG_BINARY.
type = REG_MULTI_SZ;
QStringList l = variantListToStringList(value.toList());
QStringList::const_iterator it = l.constBegin();
for (; it != l.constEnd(); ++it) {
if ((*it).length() == 0 || it->contains(QChar::Null)) {
type = REG_BINARY;
break;
}
}
if (type == REG_BINARY) {
QString s = variantToString(value);
regValueBuff = QByteArray(reinterpret_cast<const char*>(s.utf16()), s.length() * 2);
} else {
QStringList::const_iterator it = l.constBegin();
for (; it != l.constEnd(); ++it) {
const QString &s = *it;
regValueBuff += QByteArray(reinterpret_cast<const char*>(s.utf16()), (s.length() + 1) * 2);
}
regValueBuff.append((char)0);
regValueBuff.append((char)0);
}
break;
}
case QVariant::Int:
case QVariant::UInt: {
type = REG_DWORD;
qint32 i = value.toInt();
regValueBuff = QByteArray(reinterpret_cast<const char*>(&i), sizeof(qint32));
break;
}
case QVariant::LongLong:
case QVariant::ULongLong: {
type = REG_QWORD;
qint64 i = value.toLongLong();
regValueBuff = QByteArray(reinterpret_cast<const char*>(&i), sizeof(qint64));
break;
}
case QVariant::ByteArray:
Q_FALLTHROUGH();
default: {
// If the string does not contain '\0', we can use REG_SZ, the native registry
// string type. Otherwise we use REG_BINARY.
QString s = variantToString(value);
type = s.contains(QChar::Null) ? REG_BINARY : REG_SZ;
int length = s.length();
if (type == REG_SZ)
++length;
regValueBuff = QByteArray(reinterpret_cast<const char *>(s.utf16()),
int(sizeof(wchar_t)) * length);
break;
}
}
// set the value
LONG res = RegSetValueEx(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()), 0, type,
reinterpret_cast<const unsigned char*>(regValueBuff.constData()),
regValueBuff.size());
if (res == ERROR_SUCCESS) {
deleteWriteHandleOnExit = false;
} else {
qErrnoWarning(int(res), "QSettings: failed to set subkey \"%ls\"",
qUtf16Printable(rKey));
setStatus(QSettings::AccessError);
}
RegCloseKey(handle);
}
bool QWinSettingsPrivate::get(const QString &uKey, QVariant *value) const
{
QString rKey = escapedKey(uKey);
for (const RegistryKey &r : regList) {
HKEY handle = r.handle();
if (handle != 0 && readKey(handle, rKey, value))
return true;
if (!fallbacks)
return false;
}
return false;
}
QStringList QWinSettingsPrivate::children(const QString &uKey, ChildSpec spec) const
{
NameSet result;
QString rKey = escapedKey(uKey);
for (const RegistryKey &r : regList) {
HKEY parent_handle = r.handle();
if (parent_handle == 0)
continue;
HKEY handle = openKey(parent_handle, KEY_READ, rKey, access);
if (handle == 0)
continue;
if (spec == AllKeys) {
NameSet keys;
allKeys(handle, QLatin1String(""), &keys, access);
mergeKeySets(&result, keys);
} else { // ChildGroups or ChildKeys
QStringList names = childKeysOrGroups(handle, spec);
mergeKeySets(&result, names);
}
RegCloseKey(handle);
if (!fallbacks)
return result.keys();
}
return result.keys();
}
void QWinSettingsPrivate::clear()
{
remove(QString());
deleteWriteHandleOnExit = true;
}
void QWinSettingsPrivate::sync()
{
RegFlushKey(writeHandle());
}
void QWinSettingsPrivate::flush()
{
// Windows does this for us.
}
QString QWinSettingsPrivate::fileName() const
{
if (regList.isEmpty())
return QString();
const RegistryKey &key = regList.at(0);
QString result;
if (key.parentHandle() == HKEY_CURRENT_USER)
result = QLatin1String("\\HKEY_CURRENT_USER\\");
else
result = QLatin1String("\\HKEY_LOCAL_MACHINE\\");
return result + regList.at(0).key();
}
bool QWinSettingsPrivate::isWritable() const
{
return writeHandle() != 0;
}
QSettingsPrivate *QSettingsPrivate::create(QSettings::Format format, QSettings::Scope scope,
const QString &organization, const QString &application)
{
switch (format) {
case QSettings::NativeFormat:
return new QWinSettingsPrivate(scope, organization, application);
case QSettings::Registry32Format:
return new QWinSettingsPrivate(scope, organization, application, KEY_WOW64_32KEY);
case QSettings::Registry64Format:
return new QWinSettingsPrivate(scope, organization, application, KEY_WOW64_64KEY);
default:
break;
}
return new QConfFileSettingsPrivate(format, scope, organization, application);
}
QSettingsPrivate *QSettingsPrivate::create(const QString &fileName, QSettings::Format format)
{
switch (format) {
case QSettings::NativeFormat:
return new QWinSettingsPrivate(fileName);
case QSettings::Registry32Format:
return new QWinSettingsPrivate(fileName, KEY_WOW64_32KEY);
case QSettings::Registry64Format:
return new QWinSettingsPrivate(fileName, KEY_WOW64_64KEY);
default:
break;
}
return new QConfFileSettingsPrivate(fileName, format);
}
QT_END_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink