QStandardPaths Class
La classe QStandardPaths propose des méthodes permettant d'accéder aux chemins d'accès standard. En savoir plus...
| En-tête : | #include <QStandardPaths> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
Types publics
| enum | LocateOption { LocateFile, LocateDirectory } |
| flags | LocateOptions |
| enum | StandardLocation { DesktopLocation, DocumentsLocation, FontsLocation, ApplicationsLocation, MusicLocation, …, GenericStateLocation } |
Membres publics statiques
| QString | displayName(QStandardPaths::StandardLocation type) |
| QString | findExecutable(const QString &executableName, const QStringList &paths = QStringList()) |
| QString | locate(QStandardPaths::StandardLocation type, const QString &fileName, QStandardPaths::LocateOptions options = LocateFile) |
| QStringList | locateAll(QStandardPaths::StandardLocation type, const QString &fileName, QStandardPaths::LocateOptions options = LocateFile) |
| void | setTestModeEnabled(bool testMode) |
| QStringList | standardLocations(QStandardPaths::StandardLocation type) |
| QString | writableLocation(QStandardPaths::StandardLocation type) |
Description détaillée
Cette classe contient des fonctions permettant d'interroger des emplacements standard du système de fichiers local, pour des tâches courantes telles que les répertoires spécifiques à l'utilisateur ou les répertoires de configuration à l'échelle du système.
Documentation sur les types de membres
enum QStandardPaths::LocateOption
flags QStandardPaths::LocateOptions
Cette énumération décrit les différents indicateurs pouvant être utilisés pour contrôler le comportement de QStandardPaths::locate et QStandardPaths::locateAll.
| Constante | Valeur | Description |
|---|---|---|
QStandardPaths::LocateFile | 0x0 | ne renvoie que les fichiers |
QStandardPaths::LocateDirectory | 0x1 | Renvoie uniquement les répertoires |
Le type LocateOptions est un typedef pour QFlags<LocateOption>. Il stocke une combinaison OU de valeurs LocateOption.
enum QStandardPaths::StandardLocation
Cette énumération décrit les différents emplacements pouvant être interrogés à l'aide de méthodes telles que QStandardPaths::writableLocation, QStandardPaths::standardLocations et QStandardPaths::displayName.
QStandardPaths Elle décrit chaque emplacement selon deux axes indépendants : la portée de l'application (privée à l'application appelante ou partagée entre les applications) et la portée utilisateur (ancrée dans les répertoires de l'utilisateur appelant ou à l'échelle du système). Chaque valeur de l'énumération ci-dessous indique sa portée d'application ; les tableaux de la plateforme présentés plus bas indiquent sa portée utilisateur.
L'échange de données avec d'autres utilisateurs n'entre pas dans le champ d'application de ` QStandardPaths`.
Portée de l’application
Un emplacement est soit spécifique à une application (privé à l’application appelante), soit générique (partagé entre les applications exécutées par le même utilisateur). Les emplacements spécifiques à une application doivent être considérés comme inaccessibles par d’autres applications, même lorsqu’elles sont exécutées par le même utilisateur.
Applications en bac à sable
Pour les applications en bac à sable, sur des plateformes telles qu’iOS, Android ou macOS, même les emplacements génériques peuvent être ancrés dans le conteneur de bac à sable de l’application (<APPROOT> dans les tableaux ci-dessous). En pratique, cela efface la distinction entre les emplacements au niveau de l’application et ceux au niveau du système : chaque emplacement devient alors de fait spécifique à l’application, et les répertoires partagés à l’échelle du système de l’utilisateur ne sont accessibles que via les sélecteurs fournis par le système, par exemple QFileDialog.
Portée utilisateur
Un emplacement est soit local à l’utilisateur (situé dans le répertoire personnel ou les répertoires propres à l’utilisateur appelant), soit à l’échelle du système (rempli par le système d’exploitation ou par des gestionnaires de paquets, partagé entre les utilisateurs et généralement en lecture seule pour les applications).
L’appel de la fonction ` writableLocation()` renvoie le répertoire dans lequel les fichiers doivent être écrits, qui relève généralement de la portée utilisateur. Pour les emplacements spécifiques à une application, il relève également de la portée de l’application appelante.
L'appel de la fonction ` standardLocations()` renvoie d’abord le chemin accessible en écriture (s’il peut être déterminé), suivi d’un ou plusieurs emplacements supplémentaires, comprenant à la fois les emplacements locaux à l’utilisateur et les emplacements système de secours. Ces emplacements supplémentaires sont utilisés par les fonctions ` locate()` et ` locateAll()` pour rechercher des fichiers existants.
Applications en bac à sable
Pour les applications en bac à sable, les emplacements à l’échelle du système se situent généralement en dehors du conteneur de bac à sable de l’application et peuvent ne pas exister du point de vue de celle-ci, sans parler d’être lisibles ou accessibles en écriture. Elles figurent néanmoins dans les tableaux de la plateforme ci-dessous par souci de symétrie avec le cas hors bac à sable, et afin de couvrir les applications auxquelles l’accès a été accordé via des autorisations ou des sélecteurs pilotés par l’utilisateur. Les appelants ne doivent pas supposer que chaque entrée renvoyée par standardLocations() existe ou est accessible.
| Constante | Valeur | Description |
|---|---|---|
QStandardPaths::DesktopLocation | 0 | Répertoire du bureau de l’utilisateur. Sur les systèmes ne disposant pas de concept de bureau, cette valeur est identique à HomeLocation. Générique. |
QStandardPaths::DocumentsLocation | 1 | Répertoire contenant les fichiers de documents. Le chemin renvoyé n’est jamais vide. Générique. |
QStandardPaths::FontsLocation | 2 | Répertoire contenant les polices. Notez que l’installation de polices peut nécessiter des opérations supplémentaires spécifiques à la plate-forme. Générique. |
QStandardPaths::ApplicationsLocation | 3 | Répertoire contenant les applications (qu'il s'agisse d'exécutables, de bundles d'applications ou de raccourcis vers ceux-ci). Notez que l'installation d'applications peut nécessiter des opérations supplémentaires spécifiques à la plate-forme. Les fichiers, dossiers ou raccourcis présents dans ce répertoire sont spécifiques à la plate-forme. Générique. |
QStandardPaths::MusicLocation | 4 | Répertoire contenant de la musique ou d’autres fichiers audio. Si aucun répertoire de ce type n’existe, un emplacement de secours approprié pour le stockage des documents est renvoyé. Générique. |
QStandardPaths::MoviesLocation | 5 | Répertoire contenant des films et des vidéos. Si ce répertoire n’existe pas, une solution de repli appropriée pour le stockage des documents est renvoyée. Générique. |
QStandardPaths::PicturesLocation | 6 | Répertoire contenant des images ou des photos. Si aucun répertoire de ce type n’existe, un emplacement de secours approprié pour le stockage des documents est renvoyé. Générique. |
QStandardPaths::TempLocation | 7 | Répertoire dans lequel les fichiers temporaires peuvent être stockés. La valeur renvoyée peut être spécifique à l’application, partagée avec d’autres applications de cet utilisateur, voire valable à l’échelle du système. Le chemin renvoyé n’est jamais vide. Variable. |
QStandardPaths::HomeLocation | 8 | Le répertoire personnel de l’utilisateur (identique à ` QDir::homePath()`). Sur les systèmes Unix, cela correspond à la variable d’environnement HOME. Le chemin renvoyé n’est jamais vide. Générique. |
QStandardPaths::AppLocalDataLocation | 9 | Chemin d’accès aux données locales sous Windows. Sur toutes les autres plateformes, identique à AppDataLocation. Spécifique à l’application. Cette valeur d’énumération a été ajoutée dans Qt 5.4. |
QStandardPaths::CacheLocation | 10 | Répertoire dans lequel les données non essentielles (mises en cache) doivent être écrites. Le chemin renvoyé n’est jamais vide. Spécifique à l’application. |
QStandardPaths::GenericCacheLocation | 15 | Répertoire dans lequel les données non essentielles (mises en cache) partagées entre les applications doivent être écrites. Notez que le chemin renvoyé peut être vide si le système ne prend pas en charge le concept de cache partagé. Générique. |
QStandardPaths::GenericDataLocation | 11 | Répertoire dans lequel les données persistantes partagées entre les applications peuvent être stockées. Le chemin renvoyé n’est jamais vide. Générique. |
QStandardPaths::RuntimeLocation | 12 | Répertoire dans lequel les fichiers de communication d'exécution doivent être écrits, comme les sockets locaux Unix. Le chemin renvoyé peut être vide sur certains systèmes. Générique. |
QStandardPaths::ConfigLocation | 13 | Répertoire dans lequel les fichiers de configuration doivent être enregistrés. Le chemin renvoyé n’est jamais vide. Peut être générique ou spécifique à l’application (voir AppConfigLocation et GenericConfigLocation pour les variantes explicites). Varie. |
QStandardPaths::DownloadLocation | 14 | Répertoire destiné aux fichiers téléchargés. Si aucun répertoire de ce type n’existe, un emplacement de secours approprié pour le stockage des documents est renvoyé. Générique. |
QStandardPaths::GenericConfigLocation | 16 | Répertoire dans lequel les fichiers de configuration partagés entre plusieurs applications doivent être enregistrés. Le chemin renvoyé n’est jamais vide. Générique. |
QStandardPaths::AppDataLocation | 17 | Répertoire dans lequel les données persistantes de l’application peuvent être stockées. Pour obtenir un chemin permettant de stocker des données à partager avec d’autres applications, utilisez GenericDataLocation. Le chemin renvoyé n’est jamais vide. Sous Windows, cela renvoie le chemin de données itinérantes. Spécifique à l’application. Cette valeur d’énumération a été ajoutée dans Qt 5.4. |
QStandardPaths::AppConfigLocation | 18 | Répertoire dans lequel les fichiers de configuration doivent être enregistrés. Le chemin renvoyé n’est jamais vide. Spécifique à l’application. Cette valeur d’énumération a été ajoutée dans Qt 5.5. |
QStandardPaths::PublicShareLocation | 19 | Répertoire dans lequel les fichiers et répertoires partagés publiquement peuvent être stockés. Notez que le chemin renvoyé peut être vide si le système ne dispose pas d’emplacement partagé publiquement. Générique. Cette valeur d’énumération a été ajoutée dans Qt 6.4. |
QStandardPaths::TemplatesLocation | 20 | Répertoire dans lequel les fichiers de modèles peuvent être stockés. Notez que le chemin renvoyé peut être vide si le système ne dispose pas d’un emplacement dédié aux modèles. Générique. Cette valeur d’énumération a été ajoutée dans Qt 6.4. |
QStandardPaths::StateLocation (since Qt 6.7) | 21 | Répertoire dans lequel les fichiers de données d'état de l'application doivent être enregistrés. Le chemin renvoyé n'est jamais vide. Spécifique à l'application. |
QStandardPaths::GenericStateLocation (since Qt 6.7) | 22 | Répertoire dans lequel les fichiers de données d'état partagés entre les applications doivent être écrits. Le chemin renvoyé n'est jamais vide. Générique. |
Le tableau suivant donne des exemples de chemins d’accès sur différents systèmes d’exploitation. Le premier chemin est le chemin accessible en écriture (sauf indication contraire). Les autres chemins, le cas échéant, représentent des emplacements non accessibles en écriture.
| Type de chemin | macOS | Windows |
|---|---|---|
| Emplacement sur le bureau | « ~/Bureau » | « C:/Utilisateurs/<UTILISATEUR>/Bureau » |
| Emplacement du bureau | « ~/Documents » | « C:/Utilisateurs/<UTILISATEUR>/Documents » |
| Emplacement des polices | « ~/Bibliothèque/Polices », « /Bibliothèque/Polices », « /Système/Bibliothèque/Polices » | « C:/Windows/Fonts » (non accessible en écriture) |
| Emplacement des applications | « ~/Applications », « /Applications » | « C:/Users/<UTILISATEUR>/AppData/Roaming/Microsoft/Windows/Start Menu/Programs » |
| Emplacement de la musique | « ~/Musique » | « C:/Utilisateurs/<UTILISATEUR>/Musique » |
| Emplacement des films | « ~/Films » | « C:/Utilisateurs/<UTILISATEUR>/Vidéos » |
| Emplacement des images | « ~/Images » | « C:/Utilisateurs/<UTILISATEUR>/Images » |
| Emplacement des fichiers temporaires | généré aléatoirement par le système d'exploitation | « C:/Utilisateurs/<UTILISATEUR>/AppData/Local/Temp » |
| Emplacement du répertoire personnel | « ~ » | « C:/Users/<UTILISATEUR> » |
| Emplacement des données locales de l'application | « ~/Bibliothèque/Application Support/<NOM_DE_L'APPLICATION> », « /Bibliothèque/Application Support/<NOM_DE_L'APPLICATION> ». « <REPERTOIRE_DE_L'APPLICATION>/../Ressources » | « C:/Utilisateurs/<UTILISATEUR>/AppData/Local/<NOM_DE_L'APPLICATION> », « C:/ProgramData/<NOM_DE_L'APPLICATION> », « <REPERTOIRE_DE_L'APPLICATION> », « <REPERTOIRE_DE_L'APPLICATION>/data », « <REPERTOIRE_DE_L'APPLICATION>/data/<NOM_DE_L'APPLICATION> » |
| Emplacement du cache | « ~/Bibliothèque/Caches/<APPNAME> », « /Bibliothèque/Caches/<APPNAME> » | « C:/Utilisateurs/<UTILISATEUR>/AppData/Local/<NOM_DE_L'APPLICATION>/cache » |
| StateLocation | « ~/Bibliothèque/Préférences/<APPNAME>/State » | « C:/Users/<USER>/AppData/Local/<APPNAME>/State », « C:/ProgramData/<APPNAME>/State » |
| Emplacement des données génériques | « ~/Bibliothèque/Application Support », « /Bibliothèque/Application Support » | « C:/Users/<UTILISATEUR>/AppData/Local », « C:/ProgramData », « <REPERTOIRE_APPLICATION> », « <REPERTOIRE_APPLICATION>/data » |
| RuntimeLocation | « ~/Bibliothèque/Application Support » | « C:/Users/<USER> » |
| ConfigLocation | « ~/Bibliothèque/Préférences », « /Bibliothèque/Préférences » | « C:/Users/<UTILISATEUR>/AppData/Local/<NOM_DE_L'APPLICATION> », « C:/ProgramData/<NOM_DE_L'APPLICATION> » |
| GenericConfigLocation | « ~/Bibliothèque/Préférences », « /Bibliothèque/Préférences » | « C:/Users/<USER>/AppData/Local », « C:/ProgramData » |
| DownloadLocation | « ~/Téléchargements » | « C:/Users/<UTILISATEUR>/Téléchargements » |
| Emplacement du cache générique | « ~/Bibliothèque/Caches », « /Bibliothèque/Caches », « /Système/Bibliothèque/Caches » | « C:/Utilisateurs/<UTILISATEUR>/AppData/Local/cache » |
| Emplacement générique des états | « ~/Bibliothèque/Préférences/État » | « C:/Users/<USER>/AppData/Local/State », « C:/ProgramData/State » |
| AppDataLocation | « ~/Bibliothèque/Application Support/<NOM_DE_L'APPLICATION> », « /Bibliothèque/Application Support/<NOM_DE_L'APPLICATION> ». « <REPERTOIRE_DE_L'APPLICATION>/../Resources » | « C:/Users/<UTILISATEUR>/AppData/Roaming/<NOM_DE_L'APPLICATION> », « C:/ProgramData/<NOM_DE_L'APPLICATION> », « <REPERTOIRE_DE_L'APPLICATION> », « <REPERTOIRE_DE_L'APPLICATION>/data », « <REPERTOIRE_DE_L'APPLICATION>/data/<NOM_DE_L'APPLICATION> » |
| AppConfigLocation | « ~/Bibliothèque/Préférences/<APPNAME> », « /Bibliothèque/Préférences/<APPNAME> » | "C:/Utilisateurs/<UTILISATEUR>/AppData/Local/<NOM_DE_L'APPLICATION>", "C:/ProgramData/<NOM_DE_L'APPLICATION>" |
| PublicShareLocation | « ~/Public » | « C:/Utilisateurs/Public » |
| TemplatesLocation | non pris en charge | « C:/Users/<UTILISATEUR>/AppData/Roaming/Microsoft/Windows/Templates » |
Remarque : sous macOS, lorsque l'application est en mode sandbox, le système d'exploitation redirige de manière transparente le répertoire personnel de l'utilisateur vers un conteneur propre à l'application situé à l'adresse ~/Library/Containers/<BUNDLE-ID>/Data. Le tableau macOS ci-dessus reste valable, l'~ étant en réalité redirigée vers <APPROOT> pour les entrées racine utilisateur. Les solutions de repli à l’échelle du système, telles que /Library/..., /System/Library/... et <APPDIR>/../Resources, sont répertoriées par souci de symétrie, mais ne sont généralement pas accessibles sans autorisations explicites.
| Type de chemin | Linux et autres systèmes d’exploitation UNIX |
|---|---|
| DesktopLocation | « ~/Desktop » |
| Emplacement des documents | « ~/Documents » |
| Emplacement des polices | « ~/.fonts », « ~/.local/share/fonts », « /usr/local/share/fonts », « /usr/share/fonts » |
| Emplacement des applications | « ~/.local/share/applications », « /usr/local/share/applications », « /usr/share/applications » |
| Emplacement de la musique | « ~/Musique » |
| Emplacement des films | « ~/Vidéos » |
| Emplacement des images | « ~/Images » |
| Emplacement des fichiers temporaires | « /tmp » |
| Emplacement du répertoire personnel | « ~ » |
| Emplacement des données locales de l'application | « ~/.local/share/<APPNAME> », « /usr/local/share/<APPNAME> », « /usr/share/<APPNAME> » |
| Emplacement du cache | « ~/.cache/<APPNAME> » |
| StateLocation | « ~/.local/state/<APPNAME> » |
| Emplacement des données génériques | « ~/.local/share », « /usr/local/share », « /usr/share » |
| Emplacement d'exécution | « /run/user/<USER> » |
| Emplacement de configuration | « ~/.config », « /etc/xdg » |
| Emplacement de configuration générique | « ~/.config », « /etc/xdg » |
| Emplacement de téléchargement | « ~/Téléchargements » |
| Emplacement générique du cache | « ~/.cache » |
| Emplacement générique de l'état | « ~/.local/state » |
| AppDataLocation | « ~/.local/share/<APPNAME> », « /usr/local/share/<APPNAME> », « /usr/share/<APPNAME> » |
| Emplacement de la configuration de l'application | « ~/.config/<APPNAME> », « /etc/xdg/<APPNAME> » |
| Emplacement du partage public | « ~/Public » |
| TemplatesLocation | « ~/Templates » |
| Type de chemin | Android | iOS |
|---|---|---|
| Emplacement sur le bureau | « <APPROOT>/files » | « <APPROOT>/Documents/Bureau » |
| Emplacement des documents | « <USER>/Documents » [*], « <USER>/<APPNAME>/Documents » | « <APPROOT>/Documents » |
| Emplacement des polices | « /system/fonts » (non accessible en écriture) | « <APPROOT>/Library/Fonts » |
| ApplicationsLocation | non pris en charge (répertoire non accessible en lecture) | non pris en charge |
| Emplacement de la musique | « <USER>/Music » [*], « <USER>/<APPNAME>/Music » | « <APPROOT>/Documents/Musique » |
| Emplacement des films | « <UTILISATEUR>/Films » [*], « <UTILISATEUR>/<NOM DE L'APPLICATION>/Films » | « <APPROOT>/Documents/Films » |
| Emplacement des images | « <USER>/Images » [*], « <USER>/<APPNAME>/Images » | « <APPROOT>/Documents/Images », « assets-library:// » |
| Emplacement temporaire | « <APPROOT>/cache » | « <APPROOT>/tmp » |
| HomeLocation | « <APPROOT>/files » | défini par le système |
| Emplacement des données locales de l'application | « <APPROOT>/files », « <USER>/<APPNAME>/files » | « <APPROOT>/Library/Application Support » |
| CacheLocation | « <APPROOT>/cache », « <USER>/<APPNAME>/cache » | « <APPROOT>/Library/Caches » |
| StateLocation | « <APPROOT>/files/state » | « <APPROOT>/Library/Preferences/<APPNAME>/State » |
| Emplacement générique des états (il existe un état partagé) | « <APPROOT>/files/state » | « <APPROOT>/Library/Preferences/State » |
| Emplacement générique des données | « <USER> » [*] ou « <USER>/<APPNAME>/files » | « <APPROOT>/Library/Application Support » |
| RuntimeLocation | « <APPROOT>/cache » | « <APPROOT>/Library/Application Support » |
| ConfigLocation | « <APPROOT>/files/settings » | « <APPROOT>/Library/Preferences » |
| GenericConfigLocation | « <APPROOT>/files/settings » (il n'y a pas de paramètres partagés) | « <APPROOT>/Library/Preferences » |
| DownloadLocation | « <USER>/Téléchargements » [*], « <USER>/<APPNAME>/Téléchargements » | « <APPROOT>/Documents/Téléchargements » |
| Emplacement du cache générique | « <APPROOT>/cache » (il n'y a pas de cache partagé) | « <APPROOT>/Bibliothèque/Caches » |
| AppDataLocation | « <APPROOT>/files », « <USER>/<APPNAME>/files » | « <APPROOT>/Library/Application Support » |
| AppConfigLocation | « <APPROOT>/files/settings » | « <APPROOT>/Bibliothèque/Préférences/<APPNAME> » |
| PublicShareLocation | non pris en charge | « <APPROOT>/Public » |
| TemplatesLocation | non pris en charge | non pris en charge |
Dans le tableau ci-dessus, <APPNAME> correspond généralement au nom de l'organisation, au nom de l'application, ou aux deux, ou encore à un nom unique généré lors de la création du paquet. De même, <APPROOT> correspond à l'emplacement où cette application est installée (souvent un bac à sable). <APPDIR> est le répertoire contenant l'exécutable de l'application.
Il ne faut pas se fier aux chemins d'accès ci-dessus, car ils peuvent varier en fonction de la configuration du système d'exploitation, des paramètres régionaux, ou encore évoluer dans les futures versions de Qt.
Remarque : sous Android, les applications ayant des fichiers ouverts sur le stockage externe (emplacements <USER>) seront arrêtées si le stockage externe est démonté.
Remarque : sous Android 6.0 (API 23) ou version ultérieure, l’autorisation « WRITE_EXTERNAL_STORAGE » doit être demandée au moment de l’exécution lors de l’utilisation de ` QStandardPaths::writableLocation ` ou ` QStandardPaths::standardLocations`.
Remarque : sous Android, la lecture/écriture dans GenericDataLocation nécessite l’octroi des autorisations READ_EXTERNAL_STORAGE/WRITE_EXTERNAL_STORAGE.
Remarque : [ *] Sous Android 11 et versions ultérieures, les répertoires publics ne sont plus directement accessibles en mode de stockage restreint. Par conséquent, les chemins d'accès de la forme "<USER>/DirName" ne sont pas renvoyés. Vous pouvez à la place utiliser QFileDialog, qui utilise le Storage Access Framework (SAF) pour accéder à ces répertoires.
Remarque : sous iOS, si vous transmettez QStandardPaths::standardLocations(QStandardPaths::PicturesLocation).last() en tant qu’argument à QFileDialog::setDirectory(), une boîte de dialogue native de sélection d’images sera utilisée pour accéder à l’album photo de l’utilisateur. Le nom de fichier renvoyé peut être chargé à l’aide de QFile et des API associées. Cette fonctionnalité a été ajoutée dans Qt 5.5.
Voir également writableLocation(), standardLocations(), displayName(), locate() et locateAll().
Documentation sur les fonctions membres
[static] QString QStandardPaths::displayName(QStandardPaths::StandardLocation type)
Renvoie un nom d'affichage localisé pour l'emplacement donné type ou une chaîne vide QString si aucun emplacement correspondant n'est trouvé.
[static] QString QStandardPaths::findExecutable(const QString &executableName, const QStringList &paths = QStringList())
Recherche le fichier exécutable nommé « executableName » dans le répertoire spécifié « paths », ou dans les chemins d'accès système si « paths » est vide.
Sur la plupart des systèmes d’exploitation, le chemin système est déterminé par la variable d’environnement PATH. Les répertoires dans lesquels rechercher l’exécutable peuvent être définis dans l’argument paths. Pour effectuer une recherche à la fois dans vos propres chemins et dans les chemins système, appelez findExecutable deux fois : une fois avec des chemins définis et une fois avec des chemins vides. Les liens symboliques ne sont pas résolus afin de préserver le comportement des exécutables dont le fonctionnement dépend du nom avec lequel ils sont invoqués.
Remarque : sous Windows, les extensions d’exécutables courantes (issues de la variable d’environnement PATHEXT) sont automatiquement ajoutées. Par exemple, l’appel findExecutable("foo") recherche foo.exe ou foo.bat s’ils existent.
Renvoie le chemin d’accès absolu vers l’exécutable, ou une chaîne vide s’il est introuvable.
Si l’ executableName fournie est un chemin absolu pointant vers un exécutable, c’est son chemin « propre » qui est renvoyé.
[static] QString QStandardPaths::locate(QStandardPaths::StandardLocation type, const QString &fileName, QStandardPaths::LocateOptions options = LocateFile)
Recherche un fichier ou un répertoire nommé « fileName » dans les emplacements par défaut pour « type ».
Le drapeau « options » vous permet de préciser s'il faut rechercher des fichiers ou des répertoires. Par défaut, ce drapeau est défini sur « LocateFile ».
Renvoie le chemin absolu vers le premier fichier ou répertoire trouvé ; sinon, renvoie une chaîne vide.
[static] QStringList QStandardPaths::locateAll(QStandardPaths::StandardLocation type, const QString &fileName, QStandardPaths::LocateOptions options = LocateFile)
Recherche tous les fichiers ou répertoires portant le nom « fileName » dans les emplacements standard d'type.
L'indicateur « options » vous permet de préciser s'il faut rechercher des fichiers ou des répertoires. Par défaut, cet indicateur est défini sur « LocateFile ».
Renvoie la liste de tous les fichiers trouvés.
[static] void QStandardPaths::setTestModeEnabled(bool testMode)
Si testMode vaut true, cela active un « mode test » spécial dans QStandardPaths, qui redirige les emplacements accessibles en écriture vers des répertoires de test. Cela empêche les tests automatiques de lire ou d’écrire dans la configuration de l’utilisateur actuel.
Cela concerne les emplacements dans lesquels les programmes de test sont susceptibles d’écrire des fichiers : GenericDataLocation, AppDataLocation, ConfigLocation, GenericConfigLocation, AppConfigLocation, StateLocation, GenericStateLocation, GenericCacheLocation et CacheLocation. Les autres emplacements ne sont pas concernés.
Sous Unix, XDG_DATA_HOME est défini sur ~/.qttest/share, XDG_CONFIG_HOME sur ~/.qttest/config, XDG_STATE_HOME sur ~/.qttest/state et XDG_CACHE_HOME sur ~/.qttest/cache.
Sous macOS, les données sont stockées dans ~/.qttest/Application Support, le cache dans ~/.qttest/Cache et la configuration dans ~/.qttest/Preferences.
Sous Windows, tout est stocké dans un répertoire « qttest » situé sous %APPDATA%.
[static] QStringList QStandardPaths::standardLocations(QStandardPaths::StandardLocation type)
Renvoie tous les répertoires contenant des fichiers de type « type ».
La liste des répertoires est triée par ordre décroissant de priorité, en commençant par writableLocation() si celui-ci peut être déterminé. Cette liste est vide si aucun emplacement n’est défini pour le type.
Voir également ` writableLocation()` ().
[static] QString QStandardPaths::writableLocation(QStandardPaths::StandardLocation type)
Renvoie le répertoire dans lequel les fichiers de ` type ` doivent être enregistrés, ou une chaîne vide si l'emplacement ne peut pas être déterminé.
Remarque : l'emplacement de stockage renvoyé peut ne pas exister ; il peut donc être nécessaire qu'il soit créé par le système ou par l'utilisateur.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
