QWinSettingsPrivate Class Reference

Inheritance diagram for QWinSettingsPrivate:

Public Functions
QStringList	children (const QString &uKey, ChildSpec spec) const
void	clear ()
QString	fileName () const
void	flush ()
bool	get (const QString &uKey, QVariant *value) const
bool	isWritable () const
	QWinSettingsPrivate (QSettings::Scope scope, const QString &organization, const QString &application)
	QWinSettingsPrivate (QString rKey)
bool	readKey (HKEY parentHandle, const QString &rSubKey, QVariant *value) const
void	remove (const QString &uKey)
void	set (const QString &uKey, const QVariant &value)
void	sync ()
HKEY	writeHandle () const
	~QWinSettingsPrivate ()
Public Functions inherited from QSettingsPrivate
QString	actualKey (const QString &key) const
void	beginGroupOrArray (const QSettingsGroup &group)
	QSettingsPrivate (QSettings::Format format)
	QSettingsPrivate (QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application)
void	requestUpdate ()
void	setStatus (QSettings::Status status) const
void	update ()
virtual	~QSettingsPrivate ()
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Properties
bool	deleteWriteHandleOnExit
RegistryKeyList	regList

Additional Inherited Members
Public Types inherited from QSettingsPrivate
enum	{   F_Application = 0x0, F_Organization = 0x1, F_User = 0x0, F_System = 0x2,   NumConfFiles = 4 }
enum	ChildSpec { AllKeys, ChildKeys, ChildGroups }
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QSettingsPrivate
static QSettingsPrivate *	create (QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application)
static QSettingsPrivate *	create (const QString &fileName, QSettings::Format format)
static void	iniEscapedKey (const QString &key, QByteArray &result)
static void	iniEscapedString (const QString &str, QByteArray &result, QTextCodec *codec)
static void	iniEscapedStringList (const QStringList &strs, QByteArray &result, QTextCodec *codec)
static bool	iniUnescapedKey (const QByteArray &key, int from, int to, QString &result)
static bool	iniUnescapedStringList (const QByteArray &str, int from, int to, QString &stringResult, QStringList &stringListResult, QTextCodec *codec)
static QString	normalizedKey (const QString &key)
static void	processChild (QString key, ChildSpec spec, QMap< QString, QString > &result)
static QStringList	splitArgs (const QString &s, int idx)
static QVariant	stringListToVariantList (const QStringList &l)
static QVariant	stringToVariant (const QString &s)
static QStringList	variantListToStringList (const QVariantList &l)
static QString	variantToString (const QVariant &v)
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)
Public Variables inherited from QSettingsPrivate
QString	applicationName
QSettings::Format	format
QTextCodec *	iniCodec
QString	organizationName
QSettings::Scope	scope
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1
Protected Variables inherited from QSettingsPrivate
bool	fallbacks
QString	groupPrefix
QStack< QSettingsGroup >	groupStack
bool	pendingChanges
int	spec
QSettings::Status	status

Detailed Description

Definition at line 378 of file qsettings_win.cpp.

Constructors and Destructors

QWinSettingsPrivate() [1/2]

QWinSettingsPrivate::QWinSettingsPrivate	(	QSettings::Scope	scope,
		const QString &	organization,
		const QString &	application
	)

Definition at line 403 of file qsettings_win.cpp.

Referenced by QSettingsPrivate::create(), and isWritable().

    : QSettingsPrivate(QSettings::NativeFormat, scope, organization, application)
{
    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()));

            regList.append(RegistryKey(HKEY_CURRENT_USER, orgPrefix, !regList.isEmpty()));
        }

        if (!application.isEmpty())
            regList.append(RegistryKey(HKEY_LOCAL_MACHINE, appPrefix, !regList.isEmpty()));

        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, orgPrefix, !regList.isEmpty()));
    }

    if (regList.isEmpty())
        setStatus(QSettings::AccessError);
}

QWinSettingsPrivate() [2/2]

QWinSettingsPrivate::QWinSettingsPrivate

(

QString

rKey

)

Definition at line 431 of file qsettings_win.cpp.

    : QSettingsPrivate(QSettings::NativeFormat)
{
    deleteWriteHandleOnExit = false;

    if (rPath.startsWith(QLatin1String("\\")))
        rPath = rPath.mid(1);

    if (rPath.startsWith(QLatin1String("HKEY_CURRENT_USER\\")))
        regList.append(RegistryKey(HKEY_CURRENT_USER, rPath.mid(18), false));
    else if (rPath == QLatin1String("HKEY_CURRENT_USER"))
        regList.append(RegistryKey(HKEY_CURRENT_USER, QString(), false));
    else if (rPath.startsWith(QLatin1String("HKEY_LOCAL_MACHINE\\")))
        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, rPath.mid(19), false));
    else if (rPath == QLatin1String("HKEY_LOCAL_MACHINE"))
        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, QString(), false));
    else if (rPath.startsWith(QLatin1String("HKEY_CLASSES_ROOT\\")))
        regList.append(RegistryKey(HKEY_CLASSES_ROOT, rPath.mid(18), false));
    else if (rPath == QLatin1String("HKEY_CLASSES_ROOT"))
        regList.append(RegistryKey(HKEY_CLASSES_ROOT, QString(), false));
    else if (rPath.startsWith(QLatin1String("HKEY_USERS\\")))
        regList.append(RegistryKey(HKEY_USERS, rPath.mid(11), false));
    else if (rPath == QLatin1String(QLatin1String("HKEY_USERS")))
        regList.append(RegistryKey(HKEY_USERS, QString(), false));
    else
        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, rPath, false));
}

~QWinSettingsPrivate()

QWinSettingsPrivate::~QWinSettingsPrivate

(

)

Definition at line 568 of file qsettings_win.cpp.

{
    if (deleteWriteHandleOnExit && writeHandle() != 0) {
#if defined(Q_OS_WINCE)
        remove(regList.at(0).key()); 
#else
        QString emptyKey;
        DWORD res = RegDeleteKey(writeHandle(), reinterpret_cast<const wchar_t *>(emptyKey.utf16()));
        if (res != ERROR_SUCCESS) {
            qWarning("QSettings: Failed to delete key \"%s\": %s",
                    regList.at(0).key().toLatin1().data(), errorCodeToString(res).toLatin1().data());
        }
#endif
    }

    for (int i = 0; i < regList.size(); ++i)
        regList[i].close();
}

Functions

children()

QStringList QWinSettingsPrivate::children ( const QString &  uKey, ChildSpec  spec  ) const

virtual

Implements QSettingsPrivate.

Definition at line 760 of file qsettings_win.cpp.

{
    NameSet result;
    QString rKey = escapedKey(uKey);

    for (int i = 0; i < regList.size(); ++i) {
        HKEY parent_handle = regList.at(i).handle();
        if (parent_handle == 0)
            continue;
        HKEY handle = openKey(parent_handle, KEY_READ, rKey);
        if (handle == 0)
            continue;

        if (spec == AllKeys) {
            NameSet keys;
            allKeys(handle, QLatin1String(""), &keys);
            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();
}

clear()

void QWinSettingsPrivate::clear ( )

virtual

Implements QSettingsPrivate.

Definition at line 791 of file qsettings_win.cpp.

{
    remove(QString());
    deleteWriteHandleOnExit = true;
}

fileName()

QString QWinSettingsPrivate::fileName ( ) const

virtual

Implements QSettingsPrivate.

Definition at line 807 of file qsettings_win.cpp.

{
    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();
}

flush()

void QWinSettingsPrivate::flush ( )

virtual

Implements QSettingsPrivate.

Definition at line 802 of file qsettings_win.cpp.

{
    // Windows does this for us.
}

get()

bool QWinSettingsPrivate::get ( const QString &  uKey, QVariant *  value  ) const

virtual

Implements QSettingsPrivate.

Definition at line 744 of file qsettings_win.cpp.

{
    QString rKey = escapedKey(uKey);

    for (int i = 0; i < regList.size(); ++i) {
        HKEY handle = regList.at(i).handle();
        if (handle != 0 && readKey(handle, rKey, value))
            return true;

        if (!fallbacks)
            return false;
    }

    return false;
}

isWritable()

bool QWinSettingsPrivate::isWritable ( ) const

virtual

Implements QSettingsPrivate.

Definition at line 822 of file qsettings_win.cpp.

{
    return writeHandle() != 0;
}

readKey()

bool QWinSettingsPrivate::readKey	(	HKEY	parentHandle,
		const QString &	rSubKey,
		QVariant *	value
	)		const

Definition at line 459 of file qsettings_win.cpp.

Referenced by get().

{
    QString rSubkeyName = keyName(rSubKey);
    QString rSubkeyPath = keyPath(rSubKey);

    // open a handle on the subkey
    HKEY handle = openKey(parentHandle, KEY_READ, rSubkeyPath);
    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;
    }

    // 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(((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((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((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((char*)&i, data.constData(), sizeof(int));
            if (value != 0)
                *value = i;
            break;
        }

        case REG_QWORD: {
            Q_ASSERT(data.size() == sizeof(qint64));
            qint64 i;
            memcpy((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;
}

remove()

void QWinSettingsPrivate::remove ( const QString &  uKey )

virtual

Implements QSettingsPrivate.

Definition at line 587 of file qsettings_win.cpp.

{
    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));
    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);
    if (handle != 0) {
        deleteChildGroups(handle);

        if (rKey.isEmpty()) {
            QStringList childKeys = childKeysOrGroups(handle, QSettingsPrivate::ChildKeys);

            for (int i = 0; i < childKeys.size(); ++i) {
                QString group = childKeys.at(i);

                LONG res = RegDeleteValue(handle, reinterpret_cast<const wchar_t *>(group.utf16()));
                if (res != ERROR_SUCCESS) {
                    qWarning("QSettings: RegDeleteValue failed on subkey \"%s\": %s",
                              group.toLatin1().data(), errorCodeToString(res).toLatin1().data());
                }
            }
        } else {
#if defined(Q_OS_WINCE)
            // For WinCE always Close the handle first.
            RegCloseKey(handle);
#endif
            res = RegDeleteKey(writeHandle(), reinterpret_cast<const wchar_t *>(rKey.utf16()));

            if (res != ERROR_SUCCESS) {
                qWarning("QSettings: RegDeleteKey failed on key \"%s\": %s",
                            rKey.toLatin1().data(), errorCodeToString(res).toLatin1().data());
            }
        }
        RegCloseKey(handle);
    }
}

set()

void QWinSettingsPrivate::set ( const QString &  uKey, const QVariant &  value  )

virtual

Implements QSettingsPrivate.

Definition at line 646 of file qsettings_win.cpp.

{
    if (writeHandle() == 0) {
        setStatus(QSettings::AccessError);
        return;
    }

    QString rKey = escapedKey(uKey);

    HKEY handle = createOrOpenKey(writeHandle(), registryPermissions, keyPath(rKey));
    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 || stringContainsNullChar(*it)) {
                    type = REG_BINARY;
                    break;
                }
            }

            if (type == REG_BINARY) {
                QString s = variantToString(value);
                regValueBuff = QByteArray((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((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((const char*)&i, sizeof(qint32));
            break;
        }

        case QVariant::LongLong:
        case QVariant::ULongLong: {
            type = REG_QWORD;
            qint64 i = value.toLongLong();
            regValueBuff = QByteArray((const char*)&i, sizeof(qint64));
            break;
        }

        case QVariant::ByteArray:
            // fallthrough intended

        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 = stringContainsNullChar(s) ? REG_BINARY : REG_SZ;
            if (type == REG_BINARY) {
                regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2);
            } else {
                regValueBuff = QByteArray((const char*)s.utf16(), (s.length() + 1) * 2);
            }
            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 {
        qWarning("QSettings: failed to set subkey \"%s\": %s",
                rKey.toLatin1().data(), errorCodeToString(res).toLatin1().data());
        setStatus(QSettings::AccessError);
    }

    RegCloseKey(handle);
}

sync()

void QWinSettingsPrivate::sync ( )

virtual

Implements QSettingsPrivate.

Definition at line 797 of file qsettings_win.cpp.

{
    RegFlushKey(writeHandle());
}

writeHandle()

HKEY QWinSettingsPrivate::writeHandle

(

)

const

Definition at line 558 of file qsettings_win.cpp.

Referenced by isWritable(), remove(), set(), sync(), and ~QWinSettingsPrivate().

{
    if (regList.isEmpty())
        return 0;
    const RegistryKey &key = regList.at(0);
    if (key.handle() == 0 || key.readOnly())
        return 0;
    return key.handle();
}

Properties

deleteWriteHandleOnExit

bool QWinSettingsPrivate::deleteWriteHandleOnExit

private

Definition at line 400 of file qsettings_win.cpp.

Referenced by clear(), QWinSettingsPrivate(), set(), and ~QWinSettingsPrivate().

regList

RegistryKeyList QWinSettingsPrivate::regList

private

Definition at line 399 of file qsettings_win.cpp.

Referenced by children(), fileName(), get(), QWinSettingsPrivate(), writeHandle(), and ~QWinSettingsPrivate().

---

The documentation for this class was generated from the following file:

• /src/corelib/io/qsettings_win.cpp