QSettings Class

Ausführliche Beschreibung

Benutzer erwarten normalerweise, dass sich eine Anwendung ihre Einstellungen (Fenstergrößen und -positionen, Optionen usw.) über mehrere Sitzungen hinweg merkt. Diese Informationen werden unter Windows häufig in der Systemregistrierung und unter macOS sowie iOS in Eigenschaftslistendateien gespeichert. Auf Unix-Systemen verwenden viele Anwendungen (einschließlich der KDE-Anwendungen) mangels eines Standards INI-Textdateien.

QSettings ist eine Abstraktion über diese Technologien, die es Ihnen ermöglicht, Anwendungseinstellungen auf portable Weise zu speichern und wiederherzustellen. Es unterstützt außerdem „ custom storage formats “.

Die API von QSettings basiert auf QVariant und ermöglicht es Ihnen, die meisten wertbasierten Typen wie QString, QRect und QImage mit minimalem Aufwand zu speichern.

Wenn Sie lediglich eine nicht persistente, speicherbasierte Struktur benötigen, sollten Sie stattdessen die Verwendung von QMap<QString, QVariant> in Betracht ziehen.

Grundlegende Verwendung

Beim Erstellen eines QSettings-Objekts müssen Sie den Namen Ihres Unternehmens oder Ihrer Organisation sowie den Namen Ihrer Anwendung übergeben. Wenn Ihr Produkt beispielsweise „Star Runner“ heißt und Ihr Unternehmen „MySoft“, würden Sie das QSettings-Objekt wie folgt erstellen:

    QSettings settings("MySoft", "Star Runner");

QSettings-Objekte können entweder auf dem Stack oder auf dem Heap erstellt werden (d. h. mit ` new`). Das Erstellen und Löschen eines QSettings-Objekts erfolgt sehr schnell.

Wenn Sie QSettings an vielen Stellen in Ihrer Anwendung verwenden, sollten Sie den Namen der Organisation und den Namen der Anwendung möglicherweise mit ` QCoreApplication::setOrganizationName()` und ` QCoreApplication::setApplicationName()` festlegen und anschließend den Standardkonstruktor von QSettings verwenden:

    QCoreApplication::setOrganizationName("MySoft");
    QCoreApplication::setOrganizationDomain("mysoft.com");
    QCoreApplication::setApplicationName("Star Runner");
    ...
    QSettings settings;

(Hier geben wir auch die Internetdomain der Organisation an. Wenn die Internetdomain festgelegt ist, wird sie unter macOS und iOS anstelle des Organisationsnamens verwendet, da sich macOS- und iOS-Anwendungen üblicherweise über Internetdomains identifizieren. Ist keine Domain festgelegt, wird aus dem Organisationsnamen eine fiktive Domain abgeleitet. Einzelheiten finden Sie im Abschnitt „ Platform-Specific Notes “ weiter unten.)

QSettings speichert Einstellungen. Jede Einstellung besteht aus einem Schlüssel-Wert-Paar ( QString ), das den Namen der Einstellung (den Schlüssel) angibt, und einem Wert-Objekt ( QVariant ), das die mit dem Schlüssel verknüpften Daten speichert. Um eine Einstellung zu schreiben, verwenden Sie ` setValue()`. Zum Beispiel:

    settings.setValue("editor/wrapMargin", 68);

Wenn bereits eine Einstellung mit demselben Schlüssel vorhanden ist, wird der vorhandene Wert durch den neuen Wert überschrieben. Aus Effizienzgründen werden die Änderungen möglicherweise nicht sofort im permanenten Speicher gespeichert. (Sie können jederzeit „ sync()“ aufrufen, um Ihre Änderungen zu übernehmen.)

Sie können den Wert einer Einstellung mit ` value()` abrufen:

    int margin = settings.value("editor/wrapMargin").toInt();

Wenn keine Einstellung mit dem angegebenen Namen vorhanden ist, gibt QSettings einen Null- QVariant zurück (der in die Ganzzahl 0 konvertiert werden kann). Sie können einen anderen Standardwert festlegen, indem Sie ein zweites Argument an ` value()` übergeben:

    int margin = settings.value("editor/wrapMargin", 80).toInt();

Um zu prüfen, ob ein bestimmter Schlüssel vorhanden ist, rufen Sie ` contains()` auf. Um die mit einem Schlüssel verknüpfte Einstellung zu entfernen, rufen Sie ` remove()` auf. Um die Liste aller Schlüssel abzurufen, rufen Sie ` allKeys()` auf. Um alle Schlüssel zu entfernen, rufen Sie ` clear()` auf.

QVariant und GUI-Typen

Da „ QVariant “ Teil des Moduls „ Qt Core “ ist, kann es keine Konvertierungsfunktionen für Datentypen wie „ QColor “, „ QImage “ und „ QPixmap “ bereitstellen, die Teil von „ Qt GUI “ sind. Mit anderen Worten: In „ QVariant “ gibt es keine Funktionen „ toColor() “, „ toImage() “ oder „ toPixmap() “.

Stattdessen können Sie die Vorlagenfunktion QVariant::value() verwenden. Beispiel:

QSettings settings("MySoft", "Star Runner");
QColor color = settings.value("DataPump/bgcolor").value<QColor>();

Die umgekehrte Konvertierung (z. B. von „ QColor “ zu „ QVariant “) erfolgt automatisch für alle von „ QVariant “ unterstützten Datentypen, einschließlich GUI-bezogener Typen:

QSettings settings("MySoft", "Star Runner");
QColor color = QColor(Qt::blue);
settings.setValue("DataPump/bgcolor", color);

Benutzerdefinierte Typen, die mit ` qRegisterMetaType()` registriert wurden und über Operatoren für den Datenaustausch mit einem ` QDataStream ` verfügen, können mithilfe von `QSettings` gespeichert werden.

Syntax von Abschnitten und Schlüsseln

Einstellungsschlüssel können beliebige Unicode-Zeichen enthalten. Das Dateiformat und das Betriebssystem bestimmen, ob bei ihnen die Groß-/Kleinschreibung beachtet werden muss oder nicht. Unter Windows verwenden die Registrierung und INI-Dateien Schlüssel, bei denen die Groß-/Kleinschreibung keine Rolle spielt, während benutzerdefinierte Formate, die mit ` registerFormat()` registriert wurden, beides zulassen. Auf Unix-Systemen wird bei Schlüsseln stets zwischen Groß- und Kleinschreibung unterschieden.

Um Portabilitätsprobleme zu vermeiden, befolgen Sie diese einfachen Regeln:

1. Beziehen Sie sich immer mit derselben Groß-/Kleinschreibung auf denselben Schlüssel. Wenn Sie beispielsweise an einer Stelle in Ihrem Code auf einen Schlüssel als „text fonts“ verweisen, sollten Sie ihn an anderer Stelle nicht als „Text Fonts“ bezeichnen.
2. Vermeiden Sie Schlüsselnamen, die bis auf die Groß-/Kleinschreibung identisch sind. Wenn Sie beispielsweise einen Schlüssel namens „MainWindow“ haben, versuchen Sie nicht, einen anderen Schlüssel als „mainwindow“ zu speichern.
3. Verwende keine Schrägstriche („/“ und „\“) in Abschnitts- oder Schlüsselnamen; das Backslash-Zeichen wird zur Trennung von Unterschlüsseln verwendet (siehe unten). Unter Windows werden „\“ von QSettings in „/“ umgewandelt, wodurch sie identisch werden.

Sie können hierarchische Schlüssel bilden, indem Sie das Zeichen '/' als Trennzeichen verwenden, ähnlich wie bei Unix-Dateipfaden. Zum Beispiel:

    settings.setValue("mainwindow/size", win->size());
    settings.setValue("mainwindow/fullScreen", win->isFullScreen());
    settings.setValue("outputpanel/visible", panel->isVisible());

Wenn du viele Einstellungen mit demselben Präfix speichern oder wiederherstellen möchtest, kannst du das Präfix mit ` beginGroup()` angeben und am Ende ` endGroup()` aufrufen. Hier noch einmal dasselbe Beispiel, diesmal jedoch unter Verwendung des Gruppenmechanismus:

    settings.beginGroup("mainwindow");
    settings.setValue("size", win->size());
    settings.setValue("fullScreen", win->isFullScreen());
    settings.endGroup();

    settings.beginGroup("outputpanel");
    settings.setValue("visible", panel->isVisible());
    settings.endGroup();

Wird eine Gruppe mit ` beginGroup()` festgelegt, ändert sich das Verhalten der meisten Funktionen entsprechend. Gruppen können rekursiv festgelegt werden.

Zusätzlich zu Gruppen unterstützt QSettings auch ein „Array“-Konzept. Weitere Informationen finden Sie unter beginReadArray() und beginWriteArray().

Fallback-Mechanismus

Nehmen wir an, Sie haben ein QSettings-Objekt mit dem Organisationsnamen „MySoft“ und dem Anwendungsnamen „Star Runner“ erstellt. Wenn Sie einen Wert nachschlagen, werden bis zu vier Speicherorte in dieser Reihenfolge durchsucht:

1. ein benutzerspezifischer Speicherort für die Anwendung „Star Runner“
2. ein benutzerspezifischer Speicherort für alle Anwendungen von MySoft
3. ein systemweiter Speicherort für die Anwendung „Star Runner“
4. ein systemweiter Speicherort für alle Anwendungen von MySoft

(Informationen dazu, wo sich diese Speicherorte auf den verschiedenen von Qt unterstützten Plattformen befinden, finden Sie unter „ Platform-Specific Notes “ weiter unten.)

Wenn ein Schlüssel am ersten Speicherort nicht gefunden wird, wird die Suche am zweiten Speicherort fortgesetzt und so weiter. Dies ermöglicht es Ihnen, systemweite oder unternehmensweite Einstellungen zu speichern und diese auf Benutzer- oder Anwendungsebene zu überschreiben. Um diesen Mechanismus zu deaktivieren, rufen Sie ` setFallbacksEnabled(false)` auf.

Obwohl Schlüssel aus allen vier Speicherorten zum Lesen verfügbar sind, ist nur die erste Datei (der benutzerspezifische Speicherort für die jeweilige Anwendung) zum Schreiben zugänglich. Um in eine der anderen Dateien zu schreiben, lassen Sie den Anwendungsnamen weg und/oder geben Sie „ QSettings::SystemScope “ an (im Gegensatz zu „ QSettings::UserScope “, der Standardeinstellung).

Sehen wir uns ein Beispiel an:

    QSettings obj1("MySoft", "Star Runner");
    QSettings obj2("MySoft");
    QSettings obj3(QSettings::SystemScope, "MySoft", "Star Runner");
    QSettings obj4(QSettings::SystemScope, "MySoft");

Die folgende Tabelle fasst zusammen, welche QSettings-Objekte auf welchen Speicherort zugreifen.„X“ bedeutet, dass der Speicherort der dem QSettings-Objekt zugeordnete Hauptspeicherort ist und sowohl zum Lesen als auch zum Schreiben verwendet wird; „o“ bedeutet, dass der Speicherort beim Lesen als Ausweichspeicherort dient.

Das Schöne an diesem Mechanismus ist, dass er auf allen von Qt unterstützten Plattformen funktioniert und Ihnen dennoch viel Flexibilität bietet, ohne dass Sie Dateinamen oder Registrierungs-Pfade angeben müssen.

Wenn Sie auf allen Plattformen INI-Dateien anstelle der nativen API verwenden möchten, können Sie „ QSettings::IniFormat “ als erstes Argument an den QSettings-Konstruktor übergeben, gefolgt vom Geltungsbereich, dem Organisationsnamen und dem Anwendungsnamen:

    QSettings settings(QSettings::IniFormat, QSettings::UserScope,
                       "MySoft", "Star Runner");

Beachten Sie, dass INI-Dateien die Unterscheidung zwischen numerischen Daten und den zu ihrer Kodierung verwendeten Zeichenketten aufheben, sodass als Zahlen geschriebene Werte als „ QString “ zurückgelesen werden. Der numerische Wert kann mithilfe von „ QString::toInt()“, „ QString::toDouble()“ und verwandten Funktionen wiederhergestellt werden.

Wiederherstellen des Zustands einer GUI-Anwendung

QSettings wird häufig verwendet, um den Zustand einer GUI-Anwendung zu speichern. Das folgende Beispiel veranschaulicht, wie man mit QSettings die Geometrie des Hauptfensters einer Anwendung speichert und wiederherstellt.

void MainWindow::writeSettings()
{
    QSettings settings("Moose Soft", "Clipper");

    settings.beginGroup("MainWindow");
    settings.setValue("geometry", saveGeometry());
    settings.endGroup();
}

void MainWindow::readSettings()
{
    QSettings settings("Moose Soft", "Clipper");

    settings.beginGroup("MainWindow");
    const auto geometry = settings.value("geometry", QByteArray()).toByteArray();
    if (geometry.isEmpty())
        setGeometry(200, 200, 400, 400);
    else
        restoreGeometry(geometry);
    settings.endGroup();
}

Unter „Fenstergeometrie“ wird erläutert, warum es besser ist, QWidget::resize() und QWidget::move() anstelle von QWidget::setGeometry() aufzurufen, um die Geometrie eines Fensters wiederherzustellen.

Die Funktionen ` readSettings() ` und ` writeSettings() ` müssen wie folgt im Konstruktor und im Ereignis-Handler für das Schließen des Hauptfensters aufgerufen werden:

MainWindow::MainWindow()
{
    ...
    readSettings();
}

void MainWindow::closeEvent(QCloseEvent *event)
{
    if (userReallyWantsToQuit()) {
        writeSettings();
        event->accept();
    } else {
        event->ignore();
    }
}

Gleichzeitiger Zugriff auf Einstellungen aus mehreren Threads oder Prozessen

QSettings ist reentrant. Das bedeutet, dass Sie verschiedene QSettings-Objekte gleichzeitig in unterschiedlichen Threads verwenden können. Diese Eigenschaft gilt auch dann, wenn die QSettings-Objekte auf dieselben Dateien auf der Festplatte (oder auf dieselben Einträge in der Systemregistrierung) verweisen. Wird eine Einstellung über ein QSettings-Objekt geändert, wird die Änderung sofort in allen anderen QSettings-Objekten sichtbar, die auf denselben Speicherort zugreifen und sich im selben Prozess befinden.

QSettings kann sicher aus verschiedenen Prozessen heraus verwendet werden (bei denen es sich um gleichzeitig ausgeführte Instanzen Ihrer Anwendung oder um völlig unterschiedliche Anwendungen handeln kann), um an denselben Systemspeicherorten zu lesen und zu schreiben, sofern bestimmte Bedingungen erfüllt sind. Bei ` QSettings::IniFormat` werden eine beratende Dateisperre und ein intelligenter Zusammenführungsalgorithmus verwendet, um die Datenintegrität zu gewährleisten. Die Voraussetzung dafür ist, dass die beschreibbare Konfigurationsdatei eine reguläre Datei ist und sich in einem Verzeichnis befindet, in dem der aktuelle Benutzer neue temporäre Dateien erstellen darf. Ist dies nicht der Fall, muss man ` setAtomicSyncRequired()` verwenden, um die Sicherheitsfunktion zu deaktivieren.

Beachten Sie, dass ` sync()` Änderungen importiert, die von anderen Prozessen vorgenommen wurden (zusätzlich zum Schreiben der Änderungen aus diesen `QSettings`).

Plattformspezifische Hinweise

Speicherorte für Anwendungseinstellungen

Wie im Abschnitt „ Fallback Mechanism “ erwähnt, speichert QSettings Einstellungen für eine Anwendung an bis zu vier Speicherorten, je nachdem, ob es sich um benutzerspezifische oder systemweite Einstellungen handelt und ob die Einstellungen anwendungsspezifisch oder organisationsweit sind. Der Einfachheit halber nehmen wir an, dass die Organisation „MySoft“ und die Anwendung „Star Runner“ heißt.

Auf Unix-Systemen werden bei Verwendung des Dateiformats „ NativeFormat “ standardmäßig die folgenden Dateien verwendet:

1. $HOME/.config/MySoft/Star Runner.conf
2. $HOME/.config/MySoft.conf
3. für jedes Verzeichnis <dir> in $XDG_CONFIG_DIRS: <dir>/MySoft/Star Runner.conf
4. für jedes Verzeichnis <dir> in $XDG_CONFIG_DIRS: <dir>/MySoft.conf

Unter macOS und iOS werden bei dem Dateiformat „ NativeFormat “ standardmäßig folgende Dateien verwendet:

1. $HOME/Library/Preferences/com.MySoft.Star Runner.plist
2. $HOME/Library/Preferences/com.MySoft.plist
3. /Library/Preferences/com.MySoft.Star Runner.plist
4. /Library/Preferences/com.MySoft.plist

Unter Windows werden die Einstellungen für „ NativeFormat “ in den folgenden Registrierungsschlüsseln gespeichert:

1. HKEY_CURRENT_USER\Software\MySoft\Star Runner
2. HKEY_CURRENT_USER\Software\MySoft\OrganizationDefaults
3. HKEY_LOCAL_MACHINE\Software\MySoft\Star Runner
4. HKEY_LOCAL_MACHINE\Software\MySoft\OrganizationDefaults

Wenn das Dateiformat „ NativeFormat “ ist, befindet sich die Datei „Settings/MySoft/Star Runner.conf“ im Stammverzeichnis der Anwendung.

Wenn das Dateiformat „ IniFormat “ lautet, werden unter Unix, macOS und iOS die folgenden Dateien verwendet:

1. $HOME/.config/MySoft/Star Runner.ini
2. $HOME/.config/MySoft.ini
3. für jedes Verzeichnis <dir> in $XDG_CONFIG_DIRS: <dir>/MySoft/Star Runner.ini
4. für jedes Verzeichnis <dir> in $XDG_CONFIG_DIRS: <dir>/MySoft.ini

Unter Windows werden die folgenden Dateien verwendet:

1. FOLDERID_RoamingAppData\MySoft\Star Runner.ini
2. FOLDERID_RoamingAppData\MySoft.ini
3. FOLDERID_ProgramData\MySoft\Star Runner.ini
4. FOLDERID_ProgramData\MySoft.ini

Die Bezeichner mit dem Präfix „ FOLDERID_ “ sind spezielle Listen von Element-IDs, die an die Win32-API-Funktion „ SHGetKnownFolderPath() “ übergeben werden, um den entsprechenden Pfad zu erhalten.

FOLDERID_RoamingAppData verweist in der Regel auf C:\Users\User Name\AppData\Roaming, was auch durch die Umgebungsvariable „ %APPDATA% “ angezeigt wird.

FOLDERID_ProgramData verweist in der Regel auf C:\ProgramData.

Wenn das Dateiformat „ IniFormat “ lautet, ist dies „Settings/MySoft/Star Runner.ini“ im Stammverzeichnis der Anwendung.

Die Pfade für die Dateien „ .ini “ und „ .conf “ können mit der Funktion „ setPath()“ geändert werden. Unter Unix, macOS und iOS kann der Benutzer diese durch Setzen der Umgebungsvariablen „ XDG_CONFIG_HOME “ überschreiben; Einzelheiten finden Sie unter „ setPath()“.

Direkter Zugriff auf INI- und .plist-Dateien

Manchmal möchten Sie auf Einstellungen zugreifen, die in einer bestimmten Datei oder unter einem bestimmten Registrierungspfad gespeichert sind. Wenn Sie auf allen Plattformen eine INI-Datei direkt lesen möchten, können Sie den QSettings-Konstruktor verwenden, der einen Dateinamen als erstes Argument entgegennimmt, und als zweites Argument ` QSettings::IniFormat ` übergeben. Zum Beispiel:

QSettings settings("/home/petra/misc/myapp.ini",
                QSettings::IniFormat);

Anschließend können Sie das QSettings-Objekt verwenden, um Einstellungen in der Datei zu lesen und zu schreiben.

Unter macOS und iOS können Sie auf Property-List- .plist -Dateien zugreifen, indem Sie „ QSettings::NativeFormat “ als zweites Argument übergeben. Beispiel:

QSettings settings("/Users/petra/misc/myapp.plist",
                QSettings::NativeFormat);

Direkter Zugriff auf die Windows-Registrierung

Unter Windows ermöglicht QSettings den Zugriff auf Einstellungen, die mit QSettings (oder in einem unterstützten Format, z. B. als Zeichenkettendaten) in die Systemregistrierung geschrieben wurden. Dazu erstellen Sie ein QSettings-Objekt mit einem Pfad in der Registrierung und „ QSettings::NativeFormat “.

Beispiel:

QSettings settings("HKEY_CURRENT_USER\\Software\\Microsoft\\Office",
                QSettings::NativeFormat);

Alle Registrierungseinträge, die unter dem angegebenen Pfad erscheinen, können wie gewohnt über das QSettings-Objekt gelesen oder geschrieben werden (wobei Schrägstriche anstelle von Backslashes verwendet werden). Zum Beispiel:

settings.setValue("11.0/Outlook/Security/DontTrustInstalledFiles", 0);

Beachten Sie, dass das Backslash-Zeichen, wie bereits erwähnt, von QSettings zur Trennung von Unterschlüsseln verwendet wird. Daher können Sie keine Windows-Registrierungseinträge lesen oder schreiben, die Schrägstriche oder Backslashes enthalten; in diesem Fall sollten Sie eine native Windows-API verwenden.

Zugriff auf allgemeine Registrierungseinstellungen unter Windows

Unter Windows kann ein Schlüssel sowohl einen Wert als auch Unterschlüssel haben. Der Zugriff auf seinen Standardwert erfolgt durch die Verwendung von „Default“ oder „.“ anstelle eines Unterschlüssels:

settings.setValue("HKEY_CURRENT_USER\\MySoft\\Star Runner\\Galaxy", "Milkyway");
settings.setValue("HKEY_CURRENT_USER\\MySoft\\Star Runner\\Galaxy\\Sun", "OurStar");
settings.value("HKEY_CURRENT_USER\\MySoft\\Star Runner\\Galaxy\\Default"); // returns "Milkyway"

Auf anderen Plattformen als Windows würden „Default“ und „.“ als normale Unterschlüssel behandelt.

Plattformspezifische Einschränkungen

Obwohl QSettings versucht, die Unterschiede zwischen den verschiedenen unterstützten Plattformen auszugleichen, gibt es dennoch einige Unterschiede, die Sie bei der Portierung Ihrer Anwendung beachten sollten:

• Die Windows-Systemregistrierung weist folgende Einschränkungen auf: Ein Unterschlüssel darf 255 Zeichen nicht überschreiten, der Wert eines Eintrags darf 16.383 Zeichen nicht überschreiten und die Summe aller Werte eines Schlüssels darf 65.535 Zeichen nicht überschreiten. Eine Möglichkeit, diese Einschränkungen zu umgehen, besteht darin, die Einstellungen über die „ IniFormat “ statt über die „ NativeFormat “ zu speichern.
• Unter Windows behält QSettings bei Verwendung der Windows-Systemregistrierung den ursprünglichen Typ des Werts nicht bei. Daher kann sich der Typ des Werts ändern, wenn ein neuer Wert festgelegt wird. Beispielsweise ändert sich ein Wert vom Typ „ REG_EXPAND_SZ “ in „ REG_SZ “.
• Unter macOS und iOS gibt ` allKeys()` einige zusätzliche Schlüssel für globale Einstellungen zurück, die für alle Anwendungen gelten. Diese Schlüssel können mit ` value()` gelesen, jedoch nicht geändert, sondern nur überschrieben werden. Der Aufruf von ` setFallbacksEnabled(false)` blendet diese globalen Einstellungen aus.
• Unter macOS und iOS erwartet die von QSettings verwendete CFPreferences-API Internet-Domainnamen anstelle von Organisationsnamen. Um eine einheitliche API bereitzustellen, leitet QSettings einen fiktiven Domainnamen aus dem Organisationsnamen ab (es sei denn, der Organisationsname ist bereits ein Domainname, z. B. OpenOffice.org). Der Algorithmus hängt „.com“ an den Firmennamen an und ersetzt Leerzeichen und andere unzulässige Zeichen durch Bindestriche. Wenn Sie einen anderen Domainnamen angeben möchten, rufen Sie in Ihrer Funktion „ main() “ die Methoden „ QCoreApplication::setOrganizationDomain()“, „ QCoreApplication::setOrganizationName()“ und „ QCoreApplication::setApplicationName()“ auf und verwenden Sie anschließend den Standardkonstruktor von QSettings. Eine weitere Lösung besteht darin, Präprozessor-Direktiven zu verwenden, zum Beispiel:

  #ifdef Q_OS_DARWIN
      QSettings settings("grenoullelogique.fr", "Squash");
  #else
      QSettings settings("Grenoulle Logique", "Squash");
  #endif

• Unter macOS haben sich die Berechtigungen für den Zugriff auf Einstellungen, die nicht dem aktuellen Benutzer gehören (d. h. SystemScope), mit Version 10.7 (Lion) geändert. Vor dieser Version konnten Benutzer mit Administratorrechten darauf zugreifen. Unter 10.7 und 10.8 (Mountain Lion) ist dies nur noch für „root“ möglich. Unter 10.9 (Mavericks) ändert sich diese Regel jedoch erneut, allerdings nur für das native Format (plist-Dateien).

Sicherheitsaspekte

Die Klasse verwendet ` QDataStream `, um Daten in ` QVariant` zu deserialisieren. Daher weist sie denselben ` security consideration as QDataStream` auf und sollte nur für vertrauenswürdige Eingaben verwendet werden.