QSettings Class

When creating a https:// object, you must pass the name of your company or organization as well as the name of your application. For example, if your product is called Star Runner and your company is called MySoft, you would construct the https:// object as follows:

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

https:// objects can be created either on the stack or on the heap (i.e. using new). Constructing and destroying a https:// object is very fast.

If you use https:// from many places in your application, you might want to specify the organization name and the application name using https://() and https://(), and then use the default https:// constructor:

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

(Here, we also specify the organization's Internet domain. When the Internet domain is set, it is used on macOS and iOS instead of the organization name, since macOS and iOS applications conventionally use Internet domains to identify themselves. If no domain is set, a fake domain is derived from the organization name. See the https:// below for details.)

https:// stores settings. Each setting consists of a https:// that specifies the setting's name (the key) and a https:// that stores the data associated with the key. To write a setting, use https://(). For example:

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

If there already exists a setting with the same key, the existing value is overwritten by the new value. For efficiency, the changes may not be saved to permanent storage immediately. (You can always call https://() to commit your changes.)

You can get a setting's value back using https://():

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

If there is no setting with the specified name, https:// returns a null https:// (which can be converted to the integer 0). You can specify another default value by passing a second argument to https://():

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

To test whether a given key exists, call https://(). To remove the setting associated with a key, call https://(). To obtain the list of all keys, call https://(). To remove all keys, call https://().

Because https:// is part of the Qt Core module, it cannot provide conversion functions to data types such as https://, https://, and https://, which are part of Qt GUI. In other words, there is no toColor(), toImage(), or toPixmap() functions in https://.

Instead, you can use the https://() template function. For example:

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

The inverse conversion (e.g., from https:// to https://) is automatic for all data types supported by https://, including GUI-related types:

QSettings settings("MySoft", "Star Runner");
QColor color = palette().background().color();
settings.setValue("DataPump/bgcolor", color);

Custom types registered using https://() that have operators for streaming to and from a https:// can be stored using https://.

Setting keys can contain any Unicode characters. The Windows registry and INI files use case-insensitive keys, whereas the CFPreferences API on macOS and iOS uses case-sensitive keys. To avoid portability problems, follow these simple rules:

1. Always refer to the same key using the same case. For example, if you refer to a key as "text fonts" in one place in your code, don't refer to it as "Text Fonts" somewhere else.

2. Avoid key names that are identical except for the case. For example, if you have a key called "MainWindow", don't try to save another key as "mainwindow".

3. Do not use slashes ('/' and '\') in section or key names; the backslash character is used to separate sub keys (see below). On windows '\' are converted by https:// to '/', which makes them identical.

You can form hierarchical keys using the '/' character as a separator, similar to Unix file paths. For example:

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

If you want to save or restore many settings with the same prefix, you can specify the prefix using https://() and call https://() at the end. Here's the same example again, but this time using the group mechanism:

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

If a group is set using https://(), the behavior of most functions changes consequently. Groups can be set recursively.

In addition to groups, https:// also supports an "array" concept. See https://() and https://() for details.

Let's assume that you have created a https:// object with the organization name MySoft and the application name Star Runner. When you look up a value, up to four locations are searched in that order:

1. a user-specific location for the Star Runner application

2. a user-specific location for all applications by MySoft

3. a system-wide location for the Star Runner application

4. a system-wide location for all applications by MySoft

(See https:// below for information on what these locations are on the different platforms supported by Qt.)

If a key cannot be found in the first location, the search goes on in the second location, and so on. This enables you to store system-wide or organization-wide settings and to override them on a per-user or per-application basis. To turn off this mechanism, call https://(false).

Although keys from all four locations are available for reading, only the first file (the user-specific location for the application at hand) is accessible for writing. To write to any of the other files, omit the application name and/or specify https:// (as opposed to https://, the default).

Let's see with an example:

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

The table below summarizes which https:// objects access which location. "X" means that the location is the main location associated to the https:// object and is used both for reading and for writing; "o" means that the location is used as a fallback when reading.

The beauty of this mechanism is that it works on all platforms supported by Qt and that it still gives you a lot of flexibility, without requiring you to specify any file names or registry paths.

If you want to use INI files on all platforms instead of the native API, you can pass https:// as the first argument to the https:// constructor, followed by the scope, the organization name, and the application name:

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

Note that INI files lose the distinction between numeric data and the strings used to encode them, so values written as numbers shall be read back as https://. The numeric value can be recovered using https://(), https://() and related functions.

The https:// example lets you experiment with different settings location and with fallbacks turned on or off.

https:// is often used to store the state of a GUI application. The following example illustrates how to use https:// to save and restore the geometry of an application's main window.

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

See https:// for a discussion on why it is better to call https://() and https://() rather than https://() to restore a window's geometry.

The readSettings() and writeSettings() functions must be called from the main window's constructor and close event handler as follows:

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

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

See the Application example for a self-contained example that uses https://.

https:// is https://. This means that you can use distinct https:// object in different threads simultaneously. This guarantee stands even when the https:// objects refer to the same files on disk (or to the same entries in the system registry). If a setting is modified through one https:// object, the change will immediately be visible in any other https:// objects that operate on the same location and that live in the same process.

https:// can safely be used from different processes (which can be different instances of your application running at the same time or different applications altogether) to read and write to the same system locations, provided certain conditions are met. For https://, it uses advisory file locking and a smart merging algorithm to ensure data integrity. The condition for that to work is that the writeable configuration file must be a regular file and must reside in a directory that the current user can create new, temporary files in. If that is not the case, then one must use https://() to turn the safety off.

Note that https://() imports changes made by other processes (in addition to writing the changes from this https://).

Locations Where Application Settings Are Stored▲

Accessing INI and .plist Files Directly▲

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

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

Accessing the Windows Registry Directly▲

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

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

Accessing Common Registry Settings on Windows▲

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"

Platform Limitations▲

See also https://, https://, https://, Qt Widgets - Application Example

This enum type specifies the storage format used by https://.

On Unix, NativeFormat and IniFormat mean the same thing, except that the file extension is different (.conf for NativeFormat, .ini for IniFormat).

The INI file format is a Windows file format that Qt supports on all platforms. In the absence of an INI standard, we try to follow what Microsoft does, with the following exceptions:

• If you store types that https:// can't convert to https:// (e.g., https://, https://, and https://), Qt uses an @-based syntax to encode the type. For example:

   

  Sélectionnez

  pos = @Point(100 100)

  To minimize compatibility issues, any @ that doesn't appear at the first position in the value or that isn't followed by a Qt type (Point, Rect, Size, etc.) is treated as a normal character.

• Although backslash is a special character in INI files, most Windows applications don't escape backslashes (\) in file paths:

   

  Sélectionnez

  windir = C:\Windows

  https:// always treats backslash as a special character and provides no API for reading or writing such entries.

• The INI file format has severe restrictions on the syntax of a key. Qt works around this by using % as an escape character in keys. In addition, if you save a top-level setting (a key with no slashes in it, e.g., "someKey"), it will appear in the INI file's "General" section. To avoid overwriting other keys, if you save something using a key such as "General/someKey", the key will be located in the "%General" section, not in the "General" section.

• In line with most implementations today, https:// will assume that values in the INI file are utf-8 encoded. This means that values will be decoded as utf-8 encoded entries and written back as utf-8. To retain backward compatibility with older Qt versions, keys in the INI file are written in %-encoded format, but can be read in both %-encoded and utf-8 formats.

Compatibility with older Qt versions▲

Notes▲

See Also▲

Typedef for a pointer to a function with the following signature:

bool myReadFunc(QIODevice &device, QSettings::SettingsMap &map);

ReadFunc is used in registerFormat() as a pointer to a function that reads a set of key/value pairs. ReadFunc should read all the options in one pass, and return all the settings in the SettingsMap container, which is initially empty.

See Also▲

This enum specifies whether settings are user-specific or shared by all users of the same system.

See Also▲

Typedef for https://<https://, https://>.

See Also▲

The following status values are possible:

See Also▲

Typedef for a pointer to a function with the following signature:

bool myWriteFunc(QIODevice &device, const QSettings::SettingsMap &map);

WriteFunc is used in registerFormat() as a pointer to a function that writes a set of key/value pairs. WriteFunc is only called once, so you need to output the settings in one go.

See Also▲

QVariant QSettings::value(QAnyStringView key, const QVariant &defaultValue) const

Returns the value for setting key. If the setting doesn't exist, returns defaultValue.

If no default value is specified, a default https:// is returned.

Note that the Windows registry and INI files use case-insensitive keys, whereas the CFPreferences API on macOS and iOS uses case-sensitive keys. To avoid portability problems, see the https:// rules.

Example:

QSettings settings;
settings.setValue("animal/snake", 58);
settings.value("animal/snake", 1024).toInt();   // returns 58
settings.value("animal/zebra", 1024).toInt();   // returns 1024
settings.value("animal/zebra").toInt();         // returns 0

See Also▲

Constructs a https:// object for accessing settings of the application called application from the organization called organization, and with parent parent.

Example:

QSettings settings("Moose Tech", "Facturo-Pro");

The scope is set to https://, and the format is set to https:// (i.e. calling https://() before calling this constructor has no effect).

See Also▲

Constructs a https:// object for accessing settings of the application called application from the organization called organization, and with parent parent.

If scope is https://, the https:// object searches user-specific settings first, before it searches system-wide settings as a fallback. If scope is https://, the https:// object ignores user-specific settings and provides access to system-wide settings.

The storage format is set to https:// (i.e. calling https://() before calling this constructor has no effect).

If no application name is given, the https:// object will only access the organization-wide https://.

See Also▲

Constructs a https:// object for accessing settings of the application called application from the organization called organization, and with parent parent.

If scope is https://, the https:// object searches user-specific settings first, before it searches system-wide settings as a fallback. If scope is https://, the https:// object ignores user-specific settings and provides access to system-wide settings.

If format is https://, the native API is used for storing settings. If format is https://, the INI format is used.

If no application name is given, the https:// object will only access the organization-wide https://.

Constructs a https:// object for accessing the settings stored in the file called fileName, with parent parent. If the file doesn't already exist, it is created.

If format is https://, the meaning of fileName depends on the platform. On Unix, fileName is the name of an INI file. On macOS and iOS, fileName is the name of a .plist file. On Windows, fileName is a path in the system registry.

If format is https://, fileName is the name of an INI file.

• https:// provides no way of reading INI "path" entries, i.e., entries with unescaped slash characters. (This is because these entries are ambiguous and cannot be resolved automatically.)

• In INI files, https:// uses the @ character as a metacharacter in some contexts, to encode Qt-specific data types (e.g., @Rect), and might therefore misinterpret it when it occurs in pure INI files.

See Also▲

Constructs a https:// object for accessing settings of the application and organization set previously with a call to https://(), https://(), and https://().

The scope is https:// and the format is https://() (https:// by default). Use https://() before calling this constructor to change the default format used by this constructor.

The code

QSettings settings("Moose Soft", "Facturo-Pro");

is equivalent to

QCoreApplication::setOrganizationName("Moose Soft");
QCoreApplication::setApplicationName("Facturo-Pro");
QSettings settings;

If https://() and https://() has not been previously called, the https:// object will not be able to read or write any settings, and https://() will return https://.

You should supply both the domain (used by default on macOS and iOS) and the name (used by default elsewhere), although the code will cope if you supply only one, which will then be used (on all platforms), at odds with the usual naming of the file on platforms for which it isn't the default.

See Also▲

Constructs a https:// object in the same way as https://(https:// *parent) but with the given scope.

See Also▲

Destroys the https:// object.

Any unsaved changes will eventually be written to permanent storage.

See Also▲

Returns a list of all keys, including subkeys, that can be read using the https:// object.

Example:

QSettings settings;
settings.setValue("fridge/color", QColor(Qt::white));
settings.setValue("fridge/size", QSize(32, 96));
settings.setValue("sofa", true);
settings.setValue("tv", false);

QStringList keys = settings.allKeys();
// keys: ["fridge/color", "fridge/size", "sofa", "tv"]

If a group is set using https://(), only the keys in the group are returned, without the group prefix:

settings.beginGroup("fridge");
keys = settings.allKeys();
// keys: ["color", "size"]

See Also▲

Returns the application name used for storing the settings.

See Also▲

Appends prefix to the current group.

The current group is automatically prepended to all keys specified to https://. In addition, query functions such as https://(), https://(), and https://() are based on the group. By default, no group is set.

Groups are useful to avoid typing in the same setting paths over and over. For example:

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

This will set the value of three settings:

• mainwindow/size

• mainwindow/fullScreen

• outputpanel/visible

Call https://() to reset the current group to what it was before the corresponding beginGroup() call. Groups can be nested.

See Also▲

Adds prefix to the current group and starts reading from an array. Returns the size of the array.

Example:

struct Login {
    QString userName;
    QString password;
};
QList<Login> logins;
...

QSettings settings;
int size = settings.beginReadArray("logins");
for (int i = 0; i < size; ++i) {
    settings.setArrayIndex(i);
    Login login;
    login.userName = settings.value("userName").toString();
    login.password = settings.value("password").toString();
    logins.append(login);
}
settings.endArray();

Use https://() to write the array in the first place.

See Also▲

Adds prefix to the current group and starts writing an array of size size. If size is -1 (the default), it is automatically determined based on the indexes of the entries written.

If you have many occurrences of a certain set of keys, you can use arrays to make your life easier. For example, let's suppose that you want to save a variable-length list of user names and passwords. You could then write:

struct Login {
    QString userName;
    QString password;
};
QList<Login> logins;
...

QSettings settings;
settings.beginWriteArray("logins");
for (qsizetype i = 0; i < logins.size(); ++i) {
    settings.setArrayIndex(i);
    settings.setValue("userName", logins.at(i).userName);
    settings.setValue("password", logins.at(i).password);
}
settings.endArray();

The generated keys will have the form

• logins/size

• logins/1/userName

• logins/1/password

• logins/2/userName

• logins/2/password

• logins/3/userName

• logins/3/password

• ...

To read back an array, use https://().

See Also▲

Returns a list of all key top-level groups that contain keys that can be read using the https:// object.

Example:

QSettings settings;
settings.setValue("fridge/color", QColor(Qt::white));
settings.setValue("fridge/size", QSize(32, 96));
settings.setValue("sofa", true);
settings.setValue("tv", false);

QStringList groups = settings.childGroups();
// groups: ["fridge"]

If a group is set using https://(), the first-level keys in that group are returned, without the group prefix.

settings.beginGroup("fridge");
groups = settings.childGroups();
// groups: []

You can navigate through the entire setting hierarchy using https://() and childGroups() recursively.

See Also▲

Returns a list of all top-level keys that can be read using the https:// object.

Example:

QSettings settings;
settings.setValue("fridge/color", QColor(Qt::white));
settings.setValue("fridge/size", QSize(32, 96));
settings.setValue("sofa", true);
settings.setValue("tv", false);

QStringList keys = settings.childKeys();
// keys: ["sofa", "tv"]

If a group is set using https://(), the top-level keys in that group are returned, without the group prefix:

settings.beginGroup("fridge");
keys = settings.childKeys();
// keys: ["color", "size"]

You can navigate through the entire setting hierarchy using childKeys() and https://() recursively.

See Also▲

Removes all entries in the primary location associated to this https:// object.

Entries in fallback locations are not removed.

If you only want to remove the entries in the current https://(), use remove("") instead.

See Also▲

Returns true if there exists a setting called key; returns false otherwise.

If a group is set using https://(), key is taken to be relative to that group.

Note that the Windows registry and INI files use case-insensitive keys, whereas the CFPreferences API on macOS and iOS uses case-sensitive keys. To avoid portability problems, see the https:// rules.

See Also▲

Returns default file format used for storing settings for the https://(https:// *) constructor. If no default format is set, https:// is used.

See Also▲

Closes the array that was started using https://() or https://().

See Also▲

Resets the group to what it was before the corresponding https://() call.

Example:

settings.beginGroup("alpha");
// settings.group() == "alpha"

settings.beginGroup("beta");
// settings.group() == "alpha/beta"

settings.endGroup();
// settings.group() == "alpha"

settings.endGroup();
// settings.group() == ""

See Also▲

Reimplements: https://.

Returns true if fallbacks are enabled; returns false otherwise.

By default, fallbacks are enabled.

See Also▲

Returns the path where settings written using this https:// object are stored.

On Windows, if the format is https://, the return value is a system registry path, not a file path.

See Also▲

Returns the format used for storing the settings.

See Also▲

Returns the current group.

See Also▲

Returns true if https:// is only allowed to perform atomic saving and reloading (synchronization) of the settings. Returns false if it is allowed to save the settings contents directly to the configuration file.

The default is true.

See Also▲

Returns true if settings can be written using this https:// object; returns false otherwise.

One reason why isWritable() might return false is if https:// operates on a read-only file.

See Also▲

Returns the organization name used for storing the settings.

See Also▲

Registers a custom storage format. On success, returns a special Format value that can then be passed to the https:// constructor. On failure, returns https://.

The extension is the file extension associated to the format (without the '.').

The readFunc and writeFunc parameters are pointers to functions that read and write a set of key/value pairs. The https:// parameter to the read and write functions is always opened in binary mode (i.e., without the QIODevice::Text flag).

The caseSensitivity parameter specifies whether keys are case sensitive or not. This makes a difference when looking up values using https://. The default is case sensitive.

By default, if you use one of the constructors that work in terms of an organization name and an application name, the file system locations used are the same as for https://. Use https://() to specify other locations.

Example:

bool readXmlFile(QIODevice &device, QSettings::SettingsMap &map);
bool writeXmlFile(QIODevice &device, const QSettings::SettingsMap &map);

int main(int argc, char *argv[])
{
    const QSettings::Format XmlFormat =
            QSettings::registerFormat("xml", readXmlFile, writeXmlFile);

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

    ...
}

See Also▲

Removes the setting key and any sub-settings of key.

Example:

QSettings settings;
settings.setValue("ape");
settings.setValue("monkey", 1);
settings.setValue("monkey/sea", 2);
settings.setValue("monkey/doe", 4);

settings.remove("monkey");
QStringList keys = settings.allKeys();
// keys: ["ape"]

Be aware that if one of the fallback locations contains a setting with the same key, that setting will be visible after calling remove().

If key is an empty string, all keys in the current https://() are removed. For example:

QSettings settings;
settings.setValue("ape");
settings.setValue("monkey", 1);
settings.setValue("monkey/sea", 2);
settings.setValue("monkey/doe", 4);

settings.beginGroup("monkey");
settings.remove("");
settings.endGroup();

QStringList keys = settings.allKeys();
// keys: ["ape"]

Note that the Windows registry and INI files use case-insensitive keys, whereas the CFPreferences API on macOS and iOS uses case-sensitive keys. To avoid portability problems, see the https:// rules.

See Also▲

Returns the scope used for storing the settings.

See Also▲

Sets the current array index to i. Calls to functions such as https://(), https://(), https://(), and https://() will operate on the array entry at that index.

You must call https://() or https://() before you can call this function.

Configures whether https:// is required to perform atomic saving and reloading (synchronization) of the settings. If the enable argument is true (the default), https://() will only perform synchronization operations that are atomic. If this is not possible, https://() will fail and https://() will be an error condition.

Setting this property to false will allow https:// to write directly to the configuration file and ignore any errors trying to lock it against other processes trying to write at the same time. Because of the potential for corruption, this option should be used with care, but is required in certain conditions, like a https:// configuration file that exists in an otherwise non-writeable directory or NTFS Alternate Data Streams.

See https:// for more information on the feature.

See Also▲

Sets the default file format to the given format, which is used for storing settings for the https://(https:// *) constructor.

If no default format is set, https:// is used. See the documentation for the https:// constructor you are using to see if that constructor will ignore this function.

See Also▲

Sets whether fallbacks are enabled to b.

By default, fallbacks are enabled.

See Also▲

Sets the path used for storing settings for the given format and scope, to path. The format can be a custom format.

The table below summarizes the default values:

The default https:// paths on Unix, macOS, and iOS ($HOME/.config or $HOME/Settings) can be overridden by the user by setting the XDG_CONFIG_HOME environment variable. The default https:// paths on Unix, macOS, and iOS (/etc/xdg) can be overridden when building the Qt library using the configure script's -sysconfdir flag (see https:// for details).

Setting the https:// paths on Windows, macOS, and iOS has no effect.

See Also▲

Sets the value of setting key to value. If the key already exists, the previous value is overwritten.

Note that the Windows registry and INI files use case-insensitive keys, whereas the CFPreferences API on macOS and iOS uses case-sensitive keys. To avoid portability problems, see the https:// rules.

Example:

QSettings settings;
settings.setValue("interval", 30);
settings.value("interval").toInt();     // returns 30

settings.setValue("interval", 6.55);
settings.value("interval").toDouble();  // returns 6.55

See Also▲

Returns a status code indicating the first error that was met by https://, or https:// if no error occurred.

Be aware that https:// delays performing some operations. For this reason, you might want to call https://() to ensure that the data stored in https:// is written to disk before calling status().

See Also▲

Writes any unsaved changes to permanent storage, and reloads any settings that have been changed in the meantime by another application.

This function is called automatically from https://'s destructor and by the event loop at regular intervals, so you normally don't need to call it yourself.

See Also▲