Variables

Le comportement fondamental de qmake est influencé par les déclarations de variables qui définissent le processus de construction de chaque projet. Certaines d’entre elles déclarent des ressources, telles que des en-têtes et des fichiers source, communes à toutes les plateformes. D’autres sont utilisées pour personnaliser le comportement des compilateurs et des éditeurs de liens sur des plateformes spécifiques.

Les variables spécifiques à une plateforme suivent le modèle de nommage des variables qu’elles étendent ou modifient, mais incluent le nom de la plateforme concernée dans leur nom. Par exemple, un fichier makespec peut utiliser ` QMAKE_LIBS ` pour spécifier une liste de bibliothèques auxquelles chaque projet doit se lier, et ` QMAKE_LIBS_X11 ` serait utilisé pour étendre cette liste.

ANDROID_ABIS

Spécifie une liste d’ABI cibles Android. Les valeurs valides sont : armeabi-v7a, arm64-v8a, x86, x86_64.

Vous pouvez fournir les ABI en tant qu’argument de qmake :

qmake ANDROID_ABIS="armeabi-v7a arm64-v8a"

ANDROID_API_VERSION

Spécifie le numéro de niveau de l’API Android. Pour plus d’informations, consultez la section « Numéros de build Android ».

ANDROID_APPLICATION_ARGUMENTS

Spécifie des arguments de ligne de commande supplémentaires pour l'application Android à l'aide de la balise « android.app.arguments » dans le fichier ` AndroidManifest.xml `. Elle prend une chaîne d'arguments :

ANDROID_APPLICATION_ARGUMENTS = "arg1 arg2 arg3"

ANDROID_BUNDLED_JAR_DEPENDENCIES

Elle est utile lors de l'écriture d'un module Qt. Elle spécifie une liste de dépendances pré-intégrées utilisées par le module au format « .jar », par exemple :

ANDROID_BUNDLED_JAR_DEPENDENCIES += jar/Qt6Android.jar

ANDROID_DEPLOYMENT_DEPENDENCIES

Par défaut, androiddeployqt détecte les dépendances de votre application. Cependant, comme l'utilisation des plugins en exécution ne peut pas être détectée, il peut y avoir des faux positifs, car votre application peut dépendre de n'importe quel plugin constituant une dépendance potentielle. Si vous souhaitez réduire au minimum la taille de votre fichier ` APK`, vous pouvez remplacer la détection automatique à l’aide de cette variable. Celle-ci doit contenir une liste de tous les fichiers Qt à inclure, avec des chemins d’accès relatifs à la racine d’installation de Qt.

ANDROID_DEPLOYMENT_SETTINGS_FILE

Spécifie le chemin d’accès au fichier de configuration « android-deployment-settings.json » requis par les commandes `androiddeployqt` et ` androidtestrunner`. Cela remplace le chemin d’accès au fichier de configuration généré par `qmake` ; vous devez donc vous assurer de fournir un fichier de configuration valide.

ANDROID_EXTRA_LIBS

Liste des bibliothèques externes qui seront copiées dans le dossier ` libs ` de votre application et chargées au démarrage. Cela peut être utilisé, par exemple, pour activer OpenSSL dans votre application. Pour plus d’informations, consultez la section « Ajout de la prise en charge d’OpenSSL pour Android ».

Pour inclure des bibliothèques externes pour plusieurs ABI, chacune disposant de son propre répertoire, utilisez ce qui suit :

for (abi, ANDROID_ABIS): ANDROID_EXTRA_LIBS += $$PWD/$${abi}/library_name.so

Sinon, si l'ABI est incluse dans le nom de la bibliothèque, utilisez ce qui suit :

for (abi, ANDROID_ABIS): ANDROID_EXTRA_LIBS += $$PWD/library_name_$${abi}.so

ANDROID_EXTRA_PLUGINS

Spécifie un chemin d’accès vers des plugins C++ ou des ressources que votre application doit intégrer mais qui ne peuvent pas être fournies via le système de ressources, tels que les plugins QML. Grâce à cette variable, androiddeployqt s’assurera que tout est correctement packagé et déployé.

ANDROID_EXTRA_PLUGINS doit pointer vers le répertoire dans lequel le ou les plugins supplémentaires sont compilés. De plus, la structure du répertoire de compilation doit respecter une convention de nommage similaire à celle des plugins Qt, c'est-à-dire plugins/<nom du plugin>.

Les bibliothèques de plugins doivent respecter le format de nom libplugins_<type>_<nom>_<abi>.so. Pour ce faire, le fichier pro du plugin peut être défini comme suit :

TEMPLATE = lib
CONFIG += plugin

PLUGIN_TYPE = imageformats
DESTDIR = $$top_builddir/plugins/myplugin
TARGET = $$qt5LibraryTarget(myplugin, "plugins/$$PLUGIN_TYPE/")

avec top_builddir défini dans .qmake.conf comme suit :

top_builddir=$$shadowed($$PWD)

Cela garantira que la modification de nom correcte est appliquée à la bibliothèque du plugin (plugins/myplugin/libplugins_imageformats_myplugin_armeabi-v7a.so).

Ensuite, en supposant qu’un plugin supplémentaire de format d’image, myplugin, soit compilé dans $$DESTDIR/plugins/myplugin/, la commande suivante garantit qu’il est correctement intégré au paquet :

ANDROID_EXTRA_PLUGINS += $$top_builddir/plugins

ANDROID_FEATURES

Spécifie la liste des fonctionnalités d’un module :

ANDROID_FEATURES += android.hardware.location.gps

Pour plus d’informations, consultez la documentation Android <uses-feature>.

ANDROID_LIB_DEPENDENCIES

Elle est utile lors de l'écriture d'un module Qt. Elle spécifie une liste de dépendances précompilées utilisées par le module, par exemple :

ANDROID_LIB_DEPENDENCIES += \
    plugins/libplugins_platforms_qtforandroid.so

ANDROID_MIN_SDK_VERSION

Spécifie le niveau d'API Android minimum pour le projet. Par défaut, cette variable est définie sur le niveau d'API 23.

ANDROID_PACKAGE_SOURCE_DIR

Spécifie le chemin d'accès à un modèle de package Android personnalisé. Le modèle de package Android contient :

• le fichier AndroidManifest.xml
• le fichier build.gradle et d’autres scripts Gradle
• le fichier `res/values/libs.xml`

Le chemin spécifié par cette variable peut contenir des classes Java personnalisées dans le répertoire src. Par défaut, l'outil androiddeployqt copie le modèle d'application depuis le chemin d'installation de Qt pour Android vers le répertoire de compilation de votre projet, puis il y ajoute le contenu du chemin spécifié par cette variable, en écrasant tous les fichiers existants. Par exemple, vous pouvez créer un fichier ` AndroidManifest.xml ` personnalisé pour votre application, puis le placer directement dans le répertoire spécifié par cette variable.

ANDROID_PERMISSIONS

Spécifie la liste des autorisations d’un module :

ANDROID_PERMISSIONS += android.permission.ACCESS_FINE_LOCATION

Pour plus d'informations, consultez la documentation Android sur <uses-permission>.

ANDROID_TARGET_SDK_VERSION

Spécifie le niveau d'API Android cible pour le projet. Par défaut, cette variable est définie sur le niveau d'API 37.

ANDROID_VERSION_CODE

Spécifie le numéro de version de l'application. Pour plus d'informations, consultez la section « Gestion des versions des applications Android ».

ANDROID_VERSION_NAME

Spécifie la version de l'application sous la forme d'une chaîne de caractères lisible par l'utilisateur. Pour plus d'informations, consultez la section « Gestion des versions des applications Android ».

CONFIG

Spécifie la configuration du projet et les options du compilateur. Les valeurs sont reconnues en interne par qmake et ont une signification particulière.

Les valeurs d'CONFIG s suivantes contrôlent les options du compilateur et de l'éditeur de liens :

Lorsque vous utilisez l'option debug_and_release (qui est l'option par défaut sous Windows), le projet est traité trois fois : une fois pour générer un « méta » Makefile, puis deux autres fois pour générer un Makefile.Debug et un Makefile.Release.

Au cours de ces derniers passages, l’option « build_pass » ainsi que l’option correspondante « debug » ou « release » sont ajoutées à ` CONFIG`. Cela permet d’effectuer des tâches spécifiques à la version de compilation. Par exemple :

build_pass:CONFIG(debug, debug|release) {
    unix: TARGET = $$join(TARGET,,,_debug)
    else: TARGET = $$join(TARGET,,,d)
}

Au lieu d’écrire manuellement des conditions liées au type de compilation, certaines variables proposent des variantes spécifiques à la compilation, par exemple QMAKE_LFLAGS_RELEASE en plus de la variable générale QMAKE_LFLAGS. Il convient de les utiliser lorsqu’elles sont disponibles.

Le méta-Makefile rend les sous-compilations invoquables via les cibles debug et release, et une compilation combinée via la cible all. Lorsque l’option build_all CONFIG est utilisée, la compilation combinée est la valeur par défaut. Sinon, la dernière option CONFIG spécifiée parmi l’ensemble (debug, release) détermine la valeur par défaut. Dans ce cas, vous pouvez invoquer explicitement la cible all pour compiler les deux configurations en même temps :

make all

Lors de la liaison d’une bibliothèque, qmake s’appuie sur la plate-forme sous-jacente pour savoir à quelles autres bibliothèques cette bibliothèque est liée. Cependant, en cas de liaison statique, qmake n’obtiendra pas cette information à moins d’utiliser les options suivantes d’ CONFIG:

Les options suivantes définissent le type d’application ou de bibliothèque :

Ces options définissent des fonctionnalités spécifiques à Windows uniquement :

Consultez les Remarques sur les plateformes pour plus d’informations sur les options d’intégration des fichiers de manifeste.

Les options suivantes ne s'appliquent que sous macOS :

Le processus de compilation des bundles est également influencé par le contenu de la variable QMAKE_BUNDLE_DATA.

Les options suivantes ne s'appliquent que sur les plateformes Linux/Unix :

La variable ` CONFIG ` sera également vérifiée lors de la résolution des portées. Vous pouvez attribuer n'importe quelle valeur à cette variable.

Par exemple :

CONFIG += console newstuff
...
newstuff {
    SOURCES += new.cpp
    HEADERS += new.h
}

DEFINES

qmake ajoute les valeurs de cette variable en tant que macros de préprocesseur C du compilateur (option -D).

Par exemple :

DEFINES += USE_MY_STUFF

DEFINES_DEBUG

Spécifie les définitions du préprocesseur pour la configuration de débogage. Les valeurs de cette variable sont ajoutées à DEFINES une fois le projet chargé. Cette variable est généralement définie dans qmake.conf et n'a que rarement besoin d'être modifiée.

Cette variable a été introduite dans Qt 5.13.2.

DEFINES_RELEASE

Spécifie les définitions du préprocesseur pour la configuration de version finale. Les valeurs de cette variable sont ajoutées à DEFINES après le chargement du projet. Cette variable est généralement définie dans qmake.conf et n'a que rarement besoin d'être modifiée.

Cette variable a été introduite dans Qt 5.13.2.

DEF_FILE

Spécifie un fichier « .def » à inclure dans le projet.

DEPENDPATH

Spécifie une liste de répertoires que qmake doit parcourir pour résoudre les dépendances. Cette variable est utilisée lorsque qmake analyse les fichiers d'en-tête que vous incluez via ` #include ` dans votre code source.

DESTDIR

Spécifie l'emplacement où placer le fichier cible.

Par exemple :

DESTDIR = ../../lib

DISTFILES

Spécifie une liste de fichiers à inclure dans la cible « dist ». Cette fonctionnalité n’est prise en charge que par les spécifications UnixMake.

Par exemple :

DISTFILES += ../program.txt

DLLDESTDIR

Spécifie l'emplacement où copier la DLL de la cible.

EXTRA_TRANSLATIONS

Spécifie une liste de fichiers de traduction (.ts) contenant les traductions du texte de l'interface utilisateur dans des langues autres que la langue d'origine.

Contrairement à TRANSLATIONS, les fichiers de traduction situés dans « EXTRA_TRANSLATIONS » ne seront traités que par lrelease, et non par lupdate.

Vous pouvez utiliser CONFIG += lrelease pour compiler automatiquement les fichiers pendant la compilation, et CONFIG += lrelease embed_translations pour les rendre disponibles dans le système de ressources Qt.

Consultez le manuelQt Linguist pour plus d’informations sur l’internationalisation (i18n) et la localisation (l10n) avec Qt.

FORMS

Spécifie les fichiers d’interface utilisateur (voir le manuel «Qt Widgets Designer ») devant être traités par uic avant la compilation. Toutes les dépendances, les en-têtes et les fichiers source nécessaires à la construction de ces fichiers d’interface utilisateur seront automatiquement ajoutés au projet.

Par exemple :

FORMS = mydialog.ui \
    mywidget.ui \
        myconfig.ui

GUID

Spécifie le GUID défini dans un fichier .vcproj. Le GUID est généralement généré de manière aléatoire. Toutefois, si vous avez besoin d’un GUID fixe, vous pouvez le définir à l’aide de cette variable.

Cette variable est spécifique aux fichiers « .vcproj » ; elle est ignorée dans tous les autres cas.

HEADERS

Définit les fichiers d'en-tête du projet.

qmake détecte automatiquement si les classes présentes dans les en-têtes nécessitent l’utilisation de moc, et ajoute au projet les dépendances et fichiers appropriés pour générer et lier les fichiers moc.

Par exemple :

HEADERS = myclass.h \
          login.h \
          mainwindow.h

Voir également SOURCES.

ICON

Cette variable est utilisée uniquement sous Mac OS pour définir l'icône de l'application. Veuillez consulter la documentation relative à l'icône de l'application pour plus d'informations.

IDLSOURCES

Cette variable est utilisée uniquement sous Windows pour la génération de projets Visual Studio afin de placer les fichiers spécifiés dans le dossier « Generated Files ».

INCLUDEPATH

Spécifie les répertoires #include à parcourir lors de la compilation du projet.

Par exemple :

INCLUDEPATH = c:/msdev/include d:/stl/include

Pour spécifier un chemin contenant des espaces, mettez-le entre guillemets en suivant la méthode décrite dans la section « Espaces ».

win32:INCLUDEPATH += "C:/mylibs/extra headers"
unix:INCLUDEPATH += "/home/user/extra headers"

INSTALLS

Spécifie une liste de ressources qui seront installées lors de l'exécution de la commande « make install » ou d'une procédure d'installation similaire. Chaque élément de la liste est généralement défini à l'aide d'attributs fournissant des informations sur son emplacement d'installation.

Par exemple, la définition suivante de ` target.path ` décrit l'emplacement où la cible de compilation sera installée, et l'affectation ` INSTALLS ` ajoute la cible de compilation à la liste des ressources existantes à installer :

target.path += $$[QT_INSTALL_PLUGINS]/imageformats
INSTALLS += target

INSTALLS dispose d’un membre « .CONFIG » pouvant prendre plusieurs valeurs :

Pour plus d’informations, consultez la section « Installation de fichiers ».

Cette variable sert également à spécifier quels fichiers supplémentaires seront déployés sur les appareils embarqués.

JAVA_HOME

Spécifie le chemin d’installation du JDK/OpenJDK utilisé pour la compilation du projet.

LEXIMPLS

Spécifie une liste de fichiers d’implémentation Lex. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

LEXOBJECTS

Spécifie les noms des fichiers objets Lex intermédiaires. La valeur de cette variable est généralement gérée par qmake et n'a que rarement besoin d'être modifiée.

LEXSOURCES

Spécifie une liste de fichiers source Lex. Toutes les dépendances, les en-têtes et les fichiers source seront automatiquement ajoutés au projet pour la compilation de ces fichiers Lex.

Par exemple :

LEXSOURCES = lexer.l

LIBS

Spécifie une liste de bibliothèques à lier au projet. Si vous utilisez les indicateurs Unix « -l » (bibliothèque) et «-L» (chemin d’accès à la bibliothèque), qmake gère correctement les bibliothèques sous Windows (c’est-à-dire qu’il transmet le chemin d’accès complet de la bibliothèque à l’éditeur de liens). La bibliothèque doit exister pour que qmake puisse trouver le répertoire dans lequel se trouve une bibliothèque d’ -l.

Par exemple :

unix:LIBS += -L/usr/local/lib -lmath
win32:LIBS += c:/mylibs/math.lib

Pour spécifier un chemin contenant des espaces, mettez-le entre guillemets en utilisant la technique décrite dans la section « Espaces ».

win32:LIBS += "C:/mylibs/extra libs/extra.lib"
unix:LIBS += "-L/home/user/extra libs" -lextra

Par défaut, la liste des bibliothèques stockée dans ` LIBS ` est réduite à une liste de noms uniques avant d’être utilisée. Pour modifier ce comportement, ajoutez l’option ` no_lflags_merge ` à la variable `CONFIG ` :

CONFIG += no_lflags_merge

LIBS_PRIVATE

Spécifie une liste de bibliothèques à lier de manière privée au projet. Le comportement de cette variable est identique à celui de LIBS, sauf que les projets de bibliothèques partagées compilés pour Unix n’exposent pas ces dépendances dans leur interface de liaison.

Cela a pour conséquence que si le projet C dépend de la bibliothèque B, qui dépend elle-même de la bibliothèque A de manière privée, mais que C souhaite également utiliser directement des symboles de A, il doit lier explicitement A. En d’autres termes, les bibliothèques liées de manière privée ne sont pas exposées de manière transitive au moment de la compilation.

LITERAL_HASH

Cette variable est utilisée chaque fois qu’un caractère de hachage littéral (#) est nécessaire dans une déclaration de variable, par exemple dans un nom de fichier ou dans une chaîne transmise à une application externe.

Par exemple :

# To include a literal hash character, use the $$LITERAL_HASH variable:
urlPieces = http://doc.qt.io/qt-5/qtextdocument.html pageCount
message($$join(urlPieces, $$LITERAL_HASH))

En utilisant LITERAL_HASH de cette manière, le caractère « # » peut servir à construire une URL que la fonction message() affichera sur la console.

MAKEFILE

Spécifie le nom du Makefile généré. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

MAKEFILE_GENERATOR

Spécifie le nom du générateur de Makefile à utiliser lors de la génération d’un Makefile. La valeur de cette variable est généralement gérée en interne par qmake et n’a que rarement besoin d’être modifiée.

MSVCPROJ_*

Ces variables sont gérées en interne par qmake et ne doivent ni être modifiées ni être utilisées.

MOC_DIR

Spécifie le répertoire dans lequel tous les fichiers moc intermédiaires doivent être placés.

Par exemple :

unix:MOC_DIR = ../myproject/tmp
win32:MOC_DIR = c:/myproject/tmp

OBJECTIVE_HEADERS

Définit les fichiers d'en-tête Objective-C++ pour le projet.

qmake détecte automatiquement si les classes présentes dans les en-têtes nécessitent l'utilisation de moc, et ajoute au projet les dépendances et fichiers appropriés pour générer et lier les fichiers moc.

Cette variable est similaire à la variable HEADERS, mais permet de compiler les fichiers moc générés avec le compilateur Objective-C++.

Voir également OBJECTIVE_SOURCES.

OBJECTIVE_SOURCES

Spécifie les noms de tous les fichiers source Objective-C/C++ du projet.

Cette variable est désormais obsolète ; les fichiers Objective-C/C++ (.m et .mm) peuvent être ajoutés à la variable SOURCES.

Voir également OBJECTIVE_HEADERS.

OBJECTS

Cette variable est automatiquement renseignée à partir de la variable SOURCES. L'extension de chaque fichier source est remplacée par .o (Unix) ou .obj (Win32). Vous pouvez ajouter des objets à la liste.

OBJECTS_DIR

Spécifie le répertoire dans lequel tous les objets intermédiaires doivent être placés.

Par exemple :

unix:OBJECTS_DIR = ../myproject/tmp
win32:OBJECTS_DIR = c:/myproject/tmp

POST_TARGETDEPS

Répertorie les bibliothèques dont dépend la cible. Certains backends, tels que les générateurs de fichiers de projet Visual Studio et Xcode, ne prennent pas en charge cette variable. En général, cette variable est prise en charge en interne par ces outils de compilation, et elle est utile pour répertorier explicitement les bibliothèques statiques dépendantes.

Cette liste est placée après toutes les dépendances intégrées (et $$PRE_TARGETDEPS).

PRE_TARGETDEPS

Répertorie les bibliothèques dont dépend la cible. Certains backends, tels que les générateurs de fichiers de projet Visual Studio et Xcode, ne prennent pas en charge cette variable. En général, cette variable est prise en charge en interne par ces outils de construction, et elle est utile pour répertorier explicitement les bibliothèques statiques dépendantes.

Cette liste est placée avant toutes les dépendances intégrées.

PRECOMPILED_HEADER

Indique le fichier d'en-tête à utiliser pour créer un fichier d'en-tête précompilé, afin d'accélérer la compilation d'un projet. Les en-têtes précompilés ne sont actuellement pris en charge que sur certaines plateformes (Windows : tous les types de projets MSVC ; Apple : Xcode et Makefile ; Unix : gcc 3.3 et versions ultérieures).

PWD

Spécifie le chemin d’accès complet menant au répertoire contenant le fichier en cours d’analyse. Cela peut être utile pour faire référence à des fichiers au sein de l’arborescence des sources lors de l’écriture de fichiers de projet afin de prendre en charge les compilations fantômes.

Voir également _PRO_FILE_PWD_.

OUT_PWD

Spécifie le chemin complet menant au répertoire dans lequel qmake place le Makefile généré.

QM_FILES_RESOURCE_PREFIX

Spécifie le répertoire du système de ressources dans lequel les fichiers de .qm s seront mis à disposition par CONFIG += embed_translations.

La valeur par défaut est :/i18n/.

QM_FILES_INSTALL_PATH

Spécifie le répertoire de destination dans lequel les fichiers d'.qm s générés par CONFIG += lrelease seront installés. N'a aucun effet si CONFIG += embed_translations est défini.

QML_IMPORT_PATH

Cette variable n’est utilisée que par Qt Creator. Si vous disposez d’un module supplémentaire qui se trouve en dehors de votre installation Qt, vous pouvez spécifier son chemin d’accès ici.

Voir Qt Creator: Utilisation des modules QML avec des plugins pour plus de détails.

QMLPATHS

Attend une liste de chemins d’importation pointant vers les répertoires racines des arborescences de modules QML. Par exemple, si vous disposez d’un emplacement personnalisé pour vos modules QML, vous pouvez le spécifier ici.

QMAKE

Spécifie le nom du programme qmake lui-même et est placé dans les Makefiles générés. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKESPEC

Variable système contenant le chemin d’accès complet de la configuration qmake utilisée lors de la génération des fichiers Makefile. La valeur de cette variable est calculée automatiquement.

QMAKE_APPLE_DEVICE_ARCHS

Spécifie une liste d'architectures pour lesquelles effectuer la compilation. Par défaut, un projet est compilé pour l'architecture de la machine de développement. Cette variable permet de remplacer la valeur par défaut et de compiler pour une architecture différente ou de créer des binaires multi-architectures.

Cette variable est généralement spécifiée sur la ligne de commande ou dans le fichier de projet.

Voir Qt pour macOS pour plus d’informations.

QMAKE_AR_CMD

Spécifie la commande à exécuter lors de la création d'une bibliothèque partagée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_BUNDLE_DATA

Spécifie les données qui seront installées avec un bundle de bibliothèque ; elle est souvent utilisée pour indiquer un ensemble de fichiers d'en-tête.

Par exemple, les lignes suivantes ajoutent path/to/header_one.h et path/to/header_two.h à un groupe contenant des informations sur les en-têtes fournis avec le framework :

FRAMEWORK_HEADERS.version = Versions
FRAMEWORK_HEADERS.files = path/to/header_one.h path/to/header_two.h
FRAMEWORK_HEADERS.path = Headers
QMAKE_BUNDLE_DATA += FRAMEWORK_HEADERS

La dernière ligne ajoute les informations relatives aux en-têtes à l’ensemble des ressources qui seront installées avec le bundle de bibliothèque.

Les ensembles de bibliothèques sont créés lorsque l'option lib_bundle est ajoutée à la variable CONFIG.

Consultez les Notes sur la plate-forme pour plus d’informations sur la création de paquets de bibliothèques.

Un projet peut également utiliser cette variable pour regrouper les fichiers de traduction de l’application. La syntaxe exacte dépend du système de compilation utilisé par le projet : l’ancien système de compilation de Xcode ou son nouveau système.

Par exemple, lorsque l’extrait de code suivant est compilé à l’aide de l’ancien système de compilation :

translations_en.files = $$PWD/en.lproj/InfoPlist.strings
translations_en.path = en.lproj
QMAKE_BUNDLE_DATA += translations_en

Xcode ignorera l’emplacement d’origine de ` InfoPlist.strings ` et le fichier sera placé dans le répertoire ` Resources ` du bundle, sous le chemin ` translations_en.path ` fourni ; ainsi Resources/en.lproj/InfoPlist.strings

Avec le nouveau système de compilation, l’emplacement relatif du fichier est conservé, ce qui signifie que le fichier sera placé à tort sous Resources/en.lproj/en.lproj/InfoPlist.strings

Pour garantir un placement correct du fichier, le projet peut soit déplacer le fichier d’origine hors d’un sous-répertoire, soit choisir de ne pas spécifier la variable ` translations_en.path `.

# Approach 1
translations_en.files = $$PWD/InfoPlist.strings
translations_en.path = en.lproj

# Approach 2
translations_de.files = $$PWD/de.lproj/InfoPlist.strings

QMAKE_BUNDLE_DATA += translations_en translations_de

Voir QTBUG-98417 pour plus de détails sur la manière dont le système de compilation Xcode a modifié son comportement concernant le regroupement des fichiers de traduction.

QMAKE_BUNDLE_EXTENSION

Spécifie l’extension à utiliser pour les bundles de bibliothèques. Cela permet de créer des frameworks avec des extensions personnalisées au lieu de l’extension standard « .framework » du nom de répertoire.

Par exemple, la définition suivante donnera lieu à un framework portant l’extension « .myframework » :

QMAKE_BUNDLE_EXTENSION = .myframework

QMAKE_CC

Spécifie le compilateur C qui sera utilisé lors de la compilation de projets contenant du code source C. Seul le nom du fichier exécutable du compilateur doit être spécifié, à condition qu’il se trouve sur un chemin d’accès inclus dans la variable PATH au moment du traitement du Makefile.

QMAKE_CFLAGS

Spécifie les options du compilateur C pour la compilation d’un projet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée. Les options spécifiques aux modes débogage et production peuvent être ajustées en modifiant respectivement les variables QMAKE_CFLAGS_DEBUG et QMAKE_CFLAGS_RELEASE.

QMAKE_CFLAGS_DEBUG

Spécifie les options du compilateur C pour les compilations de débogage. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CFLAGS_RELEASE

Spécifie les options du compilateur C pour les versions de production. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO

Spécifie les options du compilateur C pour les versions finales lorsque « force_debug_info » est défini dans « CONFIG ». La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CFLAGS_SHLIB

Spécifie les options du compilateur pour la création d’une bibliothèque partagée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_CFLAGS_THREAD

Spécifie les options du compilateur pour la création d'une application multithread. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CFLAGS_WARN_OFF

Cette variable n'est utilisée que lorsque l'option CONFIG « warn_off » est activée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CFLAGS_WARN_ON

Cette variable n'est utilisée que lorsque l'option CONFIG « warn_on » est activée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et ne nécessite que rarement d'être modifiée.

QMAKE_CLEAN

Spécifie une liste de fichiers générés (par moc et uic, par exemple) et de fichiers objets à supprimer par ` make clean`.

QMAKE_CXX

Spécifie le compilateur C++ qui sera utilisé lors de la compilation de projets contenant du code source C++. Seul le nom de fichier de l’exécutable du compilateur doit être spécifié, à condition qu’il se trouve dans un chemin d’accès inclus dans la variable PATH au moment du traitement du Makefile.

QMAKE_CXXFLAGS

Spécifie les options du compilateur C++ pour la compilation d’un projet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée. Les options spécifiques aux modes de débogage et de production peuvent être ajustées en modifiant respectivement les variables QMAKE_CXXFLAGS_DEBUG et QMAKE_CXXFLAGS_RELEASE.

QMAKE_CXXFLAGS_DEBUG

Spécifie les options du compilateur C++ pour les versions de débogage. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CXXFLAGS_RELEASE

Spécifie les options du compilateur C++ pour les versions de production. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO

Spécifie les options du compilateur C++ pour les versions de production lorsque l'option « force_debug_info » est activée dans ` CONFIG`. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CXXFLAGS_SHLIB

Spécifie les options du compilateur C++ pour la création d'une bibliothèque partagée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CXXFLAGS_THREAD

Spécifie les options du compilateur C++ pour la création d'une application multithread. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_CXXFLAGS_WARN_OFF

Spécifie les options du compilateur C++ permettant de supprimer les avertissements du compilateur. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_CXXFLAGS_WARN_ON

Spécifie les options du compilateur C++ permettant de générer des avertissements de compilation. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_DEVELOPMENT_TEAM

Identifiant d’une équipe de développement à utiliser pour la signature des certificats et des profils d’approvisionnement.

QMAKE_DISTCLEAN

Spécifie une liste de fichiers à supprimer par ` make distclean`.

QMAKE_EXTENSION_SHLIB

Contient l’extension des bibliothèques partagées. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_EXTENSION_STATICLIB

Contient l'extension des bibliothèques statiques partagées. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_EXT_MOC

Contient l'extension utilisée pour les fichiers moc inclus.

Voir aussi Extensions de fichiers.

QMAKE_EXT_UI

Contient l'extension utilisée pour les fichiers d'interface utilisateur d'Qt Widgets Designer.

Voir aussi Extensions de fichiers.

QMAKE_EXT_PRL

Contient l'extension utilisée pour les fichiers PRL créés.

Voir aussi Extensions de fichiers, Dépendances de bibliothèques.

QMAKE_EXT_LEX

Contient l'extension utilisée pour les fichiers fournis à Lex.

Voir aussi Extensions de fichiers, LEXSOURCES.

QMAKE_EXT_YACC

Contient l'extension utilisée pour les fichiers fournis à Yacc.

Voir aussi Extensions de fichiers, YACCSOURCES.

QMAKE_EXT_OBJ

Contient l'extension utilisée pour les fichiers objets générés.

Voir aussi Extensions de fichiers.

QMAKE_EXT_CPP

Contient les suffixes des fichiers qui doivent être interprétés comme du code source C++.

Voir aussi Extensions de fichiers.

QMAKE_EXT_H

Contient les extensions des fichiers qui doivent être interprétés comme des fichiers d'en-tête C.

Voir aussi Extensions de fichiers.

QMAKE_EXTRA_COMPILERS

Spécifie une liste de compilateurs ou de préprocesseurs supplémentaires.

Voir aussi « Ajout de compilateurs ».

QMAKE_EXTRA_TARGETS

Spécifie une liste de cibles qmake supplémentaires.

Voir également « Ajout de cibles personnalisées ».

QMAKE_FAILED_REQUIREMENTS

Contient la liste des dépendances non satisfaites. La valeur de cette variable est définie par qmake et ne peut pas être modifiée.

Voir également requires() et REQUIRES.

QMAKE_FRAMEWORK_BUNDLE_NAME

Dans un projet de framework, cette variable contient le nom à utiliser pour le framework en cours de compilation.

Par défaut, cette variable contient la même valeur que la variable TARGET.

Voir Création de frameworks pour plus d’informations sur la création de frameworks et de bundles de bibliothèques.

QMAKE_FRAMEWORK_VERSION

Pour les projets dont la cible de compilation est un framework macOS, iOS, tvOS ou watchOS, cette variable sert à spécifier le numéro de version qui sera attribué au framework compilé.

Par défaut, cette variable contient la même valeur que la variable VERSION.

Consultez la section Création de frameworks pour plus d’informations sur la création de frameworks.

QMAKE_HOST

Fournit des informations sur la machine hôte exécutant qmake. Par exemple, vous pouvez récupérer l'architecture de la machine hôte à l'adresse QMAKE_HOST.arch.

win32-g++:contains(QMAKE_HOST.arch, x86_64):{
    message("Host is 64bit")
    ...
}

QMAKE_INCDIR

Spécifie la liste des chemins d’accès aux en-têtes système qui sont ajoutés à INCLUDEPATH. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_INCDIR_EGL

Spécifie l'emplacement des fichiers d'en-tête EGL à ajouter à INCLUDEPATH lors de la compilation d'une cible prenant en charge OpenGL/ES ou OpenVG. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_INCDIR_OPENGL

Spécifie l'emplacement des fichiers d'en-tête OpenGL à ajouter à INCLUDEPATH lors de la compilation d'une cible avec prise en charge d'OpenGL. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et doit rarement être modifiée.

Si l’implémentation OpenGL utilise EGL (la plupart des systèmes OpenGL/ES), il peut également être nécessaire de définir QMAKE_INCDIR_EGL.

QMAKE_INCDIR_OPENGL_ES2

Cette variable spécifie l'emplacement des fichiers d'en-tête OpenGL à ajouter à INCLUDEPATH lors de la compilation d'une cible prenant en charge OpenGL ES 2.

La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Si l’implémentation OpenGL utilise EGL (comme c’est le cas pour la plupart des systèmes OpenGL/ES), il peut également être nécessaire de définir QMAKE_INCDIR_EGL.

QMAKE_INCDIR_OPENVG

Spécifie l'emplacement des fichiers d'en-tête OpenVG à ajouter à INCLUDEPATH lors de la compilation d'une cible prenant en charge OpenVG. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Si l’implémentation OpenVG utilise EGL, il peut également être nécessaire de définir QMAKE_INCDIR_EGL.

QMAKE_INCDIR_X11

Spécifie l'emplacement des chemins d'accès aux fichiers d'en-tête X11 à ajouter à INCLUDEPATH lors de la compilation d'une cible X11. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_INFO_PLIST

Spécifie le nom du fichier de liste de propriétés, .plist, que vous souhaitez inclure dans le bundle de votre application macOS, iOS, tvOS et watchOS.

Dans le fichier .plist, vous pouvez définir des variables que qmake remplacera par les valeurs correspondantes :

Si vous effectuez une compilation pour iOS et que le fichier .plist contient la clé NSPhotoLibraryUsageDescription, qmake inclura un plugin supplémentaire à la compilation qui ajoute la prise en charge de l’accès aux photos (par exemple, QFile/QFileDialog). Consultez la documentation Info.plist d’Apple pour plus d’informations concernant cette clé.

QMAKE_IOS_DEPLOYMENT_TARGET

Elle spécifie la version minimale absolue d’iOS prise en charge par l’application.

Pour plus d’informations, consultez la section « Spécification des versions iOS prises en charge ».

QMAKE_IOS_LAUNCH_SCREEN

Spécifie l'écran de lancement utilisé par l'application. Si cette variable n'est pas définie, un écran de lancement par défaut est utilisé.

QMAKE_LFLAGS

Spécifie un ensemble général de drapeaux transmis à l’éditeur de liens. Si vous devez modifier les drapeaux utilisés pour une plate-forme ou un type de projet particulier, utilisez l’une des variables spécialisées prévues à cet effet plutôt que cette variable.

QMAKE_LFLAGS_CONSOLE

Spécifie les options de l'éditeur de liens pour la compilation de programmes en mode console. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_DEBUG

Spécifie les options de l'éditeur de liens pour les compilations de débogage. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_PLUGIN

Spécifie les options de l'éditeur de liens pour la compilation des plugins. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_RPATH

Spécifie les options de l'éditeur de liens nécessaires pour utiliser les valeurs de QMAKE_RPATHDIR.

La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_REL_RPATH

Spécifie les options de l'éditeur de liens nécessaires pour activer les chemins relatifs dans QMAKE_RPATHDIR.

La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_REL_RPATH_BASE

Spécifie la chaîne de caractères que l'éditeur de liens dynamique interprète comme l'emplacement de l'exécutable ou de la bibliothèque de référence.

La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_RPATHLINK

Spécifie les options de l'éditeur de liens nécessaires pour utiliser les valeurs de QMAKE_RPATHLINKDIR.

La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_RELEASE

Spécifie les options de l'éditeur de liens pour les versions de production. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_RELEASE_WITH_DEBUGINFO

Spécifie les options de l'éditeur de liens pour les versions finales lorsque la variable « force_debug_info » est définie dans ` CONFIG`. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_APP

Spécifie les options de l’éditeur de liens pour la compilation des applications. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_LFLAGS_SHLIB

Spécifie les options de l'éditeur de liens utilisées pour la compilation des bibliothèques partagées. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_SONAME

Spécifie les options de l'éditeur de liens permettant de définir le nom des objets partagés, tels que .so ou .dll. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_THREAD

Spécifie les options de l'éditeur de liens pour la compilation de projets multithread. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LFLAGS_WINDOWS

Spécifie les options de l'éditeur de liens pour la compilation de projets d'interface graphique Windows (c'est-à-dire les applications non en mode console). La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LIBDIR

Spécifie une liste de chemins de recherche des bibliothèques pour tous les projets. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Pour spécifier des chemins de recherche supplémentaires dans les fichiers de projet, utilisez plutôt LIBS comme suit :

LIBS += -L/path/to/libraries

QMAKE_LIBDIR_POST

Spécifie une liste de chemins de recherche des bibliothèques système pour tous les projets. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LIBDIR_FLAGS

Spécifie l'emplacement de tous les répertoires de bibliothèques préfixés par -L. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LIBDIR_EGL

Spécifie l'emplacement du répertoire de la bibliothèque EGL, lorsque EGL est utilisé avec OpenGL/ES ou OpenVG. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LIBDIR_OPENGL

Spécifie l'emplacement du répertoire de la bibliothèque OpenGL. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Si l’implémentation OpenGL utilise EGL (la plupart des systèmes OpenGL/ES), il peut également être nécessaire de définir QMAKE_LIBDIR_EGL.

QMAKE_LIBDIR_OPENVG

Spécifie l'emplacement du répertoire de la bibliothèque OpenVG. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Si l’implémentation OpenVG utilise EGL, il peut également être nécessaire de définir QMAKE_LIBDIR_EGL.

QMAKE_LIBDIR_X11

Spécifie l'emplacement du répertoire des bibliothèques X11. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LIBS

Spécifie les bibliothèques supplémentaires auxquelles chaque projet doit être lié. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Pour spécifier des bibliothèques dans un fichier de projet, utilisez plutôt LIBS.

QMAKE_LIBS_PRIVATE

Spécifie les bibliothèques privées supplémentaires auxquelles chaque projet doit être lié. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Pour spécifier des bibliothèques privées dans un fichier de projet de bibliothèque, utilisez plutôt LIBS_PRIVATE.

QMAKE_LIBS_EGL

Spécifie toutes les bibliothèques EGL lors de la compilation de Qt avec OpenGL/ES ou OpenVG. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée. La valeur habituelle est -lEGL.

QMAKE_LIBS_OPENGL

Spécifie toutes les bibliothèques OpenGL. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

Si l’implémentation OpenGL utilise EGL (la plupart des systèmes OpenGL/ES), il peut également être nécessaire de définir QMAKE_LIBS_EGL.

QMAKE_LIBS_OPENGL_ES1, QMAKE_LIBS_OPENGL_ES2

Ces variables spécifient toutes les bibliothèques OpenGL pour OpenGL ES 1 et OpenGL ES 2.

La valeur de ces variables est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

Si l’implémentation OpenGL utilise EGL (comme c’est le cas pour la plupart des systèmes OpenGL/ES), il peut également être nécessaire de définir QMAKE_LIBS_EGL.

QMAKE_LIBS_OPENVG

Spécifie toutes les bibliothèques OpenVG. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée. La valeur habituelle est -lOpenVG.

Certains moteurs OpenVG sont implémentés par-dessus OpenGL. Cela sera détecté lors de la phase de configuration et QMAKE_LIBS_OPENGL sera implicitement ajouté à QMAKE_LIBS_OPENVG partout où les bibliothèques OpenVG sont liées.

Si l’implémentation OpenVG utilise EGL, il peut également être nécessaire de définir QMAKE_LIBS_EGL.

QMAKE_LIBS_THREAD

Spécifie toutes les bibliothèques à lier lors de la compilation d’une cible multithread. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et doit rarement être modifiée.

QMAKE_LIBS_X11

Spécifie toutes les bibliothèques X11. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LIB_FLAG

Cette variable n’est pas vide si le modèle ` lib ` est spécifié. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_LINK

Spécifie l'éditeur de liens qui sera utilisé lors de la compilation de projets basés sur des applications. Seul le nom du fichier exécutable de l'éditeur de liens doit être spécifié, à condition qu'il se trouve sur un chemin contenu dans la variable ` PATH ` au moment du traitement du Makefile. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LINK_SHLIB_CMD

Spécifie la commande à exécuter lors de la création d'une bibliothèque partagée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LN_SHLIB

Spécifie la commande à exécuter lors de la création d'un lien vers une bibliothèque partagée. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_LRELEASE_FLAGS

Liste des options supplémentaires transmises à lrelease lorsqu’il est activé via CONFIG += lrelease.

QMAKE_OBJECTIVE_CFLAGS

Spécifie les options du compilateur Objective C/C++ pour la compilation d'un projet. Ces options s'ajoutent à celles définies par QMAKE_CFLAGS et QMAKE_CXXFLAGS.

QMAKE_POST_LINK

Spécifie la commande à exécuter après la liaison de la cible (TARGET). Cette variable est normalement vide ; par conséquent, aucune commande n'est exécutée.

QMAKE_PRE_LINK

Spécifie la commande à exécuter avant la liaison de la CIBLE. Cette variable est normalement vide ; par conséquent, aucune commande n'est exécutée.

QMAKE_PROJECT_NAME

Détermine le nom du projet lors de la génération de fichiers de projet pour les IDE. La valeur par défaut est le nom de la cible. La valeur de cette variable est généralement gérée par qmake et n'a que rarement besoin d'être modifiée.

QMAKE_PROVISIONING_PROFILE

L'UUID d'un profil d'approvisionnement valide. À utiliser conjointement avec QMAKE_DEVELOPMENT_TEAM pour spécifier le profil d'approvisionnement.

QMAKE_MAC_SDK

Cette variable est utilisée sous macOS lors de la compilation de binaires universels.

QMAKE_MACOSX_DEPLOYMENT_TARGET

Elle spécifie la version minimale absolue de macOS prise en charge par l'application.

Pour plus d'informations, consultez la section « Configurations prises en charge par macOS ».

QMAKE_MAKEFILE

Spécifie le nom du fichier Makefile à créer. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_QMAKE

Contient le chemin d'accès absolu de l'exécutable qmake.

QMAKE_RESOURCE_FLAGS

Cette variable sert à personnaliser la liste des options transmises à la Resource Compiler dans chacune des règles de construction où elle est utilisée. Par exemple, la ligne suivante garantit que les options ` -threshold ` et ` -compress ` sont utilisées avec des valeurs spécifiques à chaque fois que ` rcc ` est appelé :

QMAKE_RESOURCE_FLAGS += -threshold 0 -compress 9

QMAKE_RPATHDIR

Spécifie une liste de chemins d’accès aux bibliothèques qui sont ajoutés à l’exécutable au moment de la liaison, afin que ces chemins soient recherchés en priorité lors de l’exécution.

Lorsque des chemins relatifs sont spécifiés, qmake les transforme en une forme comprise par l’éditeur de liens dynamiques comme étant relative à l’emplacement de l’exécutable ou de la bibliothèque de référence. Cette fonctionnalité n’est prise en charge que par certaines plateformes (actuellement celles basées sur Linux et Darwin) et peut être détectée en vérifiant si la variable QMAKE_REL_RPATH_BASE est définie.

QMAKE_RPATHLINKDIR

Spécifie une liste de chemins d’accès aux bibliothèques que l’éditeur de liens statique doit parcourir pour rechercher les dépendances implicites des bibliothèques partagées. Pour plus d’informations, consultez la page de manuel de la commande ` ld(1)`.

QMAKE_RUN_CC

Spécifie la règle individuelle nécessaire à la compilation d’un objet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_RUN_CC_IMP

Spécifie la règle individuelle nécessaire à la compilation d’un objet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

QMAKE_RUN_CXX

Spécifie la règle individuelle nécessaire à la compilation d'un objet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_RUN_CXX_IMP

Spécifie la règle individuelle nécessaire à la compilation d'un objet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_SONAME_PREFIX

Si elle est définie, la valeur de cette variable est utilisée comme chemin à ajouter au début de l’identificateur « SONAME » de la bibliothèque partagée compilée. L’ SONAME est l’identificateur que l’éditeur de liens dynamiques utilisera ultérieurement pour référencer la bibliothèque. En général, cette référence peut être un nom de bibliothèque ou le chemin complet de la bibliothèque. Sous macOS, iOS, tvOS et watchOS, le chemin d’accès peut être spécifié de manière relative à l’aide des espaces réservés suivants :

Dans la plupart des cas, l'utilisation de ` @rpath ` est suffisante et recommandée :

# <project root>/project.pro
QMAKE_SONAME_PREFIX = @rpath

Cependant, le préfixe peut également être spécifié à l’aide de différents espaces réservés, ou d’un chemin absolu, tel que l’un des suivants :

# <project root>/project.pro
QMAKE_SONAME_PREFIX = @executable_path/../Frameworks
QMAKE_SONAME_PREFIX = @loader_path/Frameworks
QMAKE_SONAME_PREFIX = /Library/Frameworks

Pour plus d’informations, consultez la documentation de dyld sur les noms d’installation des bibliothèques dynamiques.

QMAKE_TARGET

Spécifie le nom de la cible du projet. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

QMAKE_TARGET_COMPANY

Windows uniquement. Spécifie la société associée à la cible du projet ; cette variable est utilisée, le cas échéant, pour insérer le nom de la société dans les propriétés de l'application. Elle n'est utilisée que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_DESCRIPTION

Windows uniquement. Spécifie la description de la cible du projet ; elle est utilisée, le cas échéant, pour insérer la description dans les propriétés de l’application. Elle n’est prise en compte que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_COPYRIGHT

Windows uniquement. Spécifie les informations de copyright pour la cible du projet ; elles sont utilisées, le cas échéant, pour insérer les informations de copyright dans les propriétés de l'application. Cette variable n'est utilisée que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_PRODUCT

Windows uniquement. Spécifie le produit de la cible du projet ; cette variable est utilisée, le cas échéant, pour ajouter le produit dans les propriétés de l’application. Elle n’est utilisée que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_ORIGINAL_FILENAME

Windows uniquement. Spécifie le nom de fichier d'origine de la cible du projet ; cette valeur est utilisée, le cas échéant, pour indiquer le nom de fichier d'origine dans les propriétés de l'application. Elle n'est utilisée que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_INTERNALNAME

Windows uniquement. Spécifie le nom interne de la cible du projet ; il est utilisé, le cas échéant, pour insérer le nom interne dans les propriétés de l'application. Il n'est utilisé que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_COMMENTS

Windows uniquement. Spécifie les commentaires relatifs à la cible du projet ; cette valeur est utilisée, le cas échéant, pour insérer les commentaires dans les propriétés de l'application. Elle n’est prise en compte que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_TARGET_TRADEMARKS

Windows uniquement. Spécifie les informations relatives aux marques déposées pour la cible du projet ; elles sont utilisées, le cas échéant, pour insérer ces informations dans les propriétés de l’application. Elles ne sont utilisées que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

QMAKE_MANIFEST

Windows uniquement. Spécifie le fichier manifeste pour la cible du projet. Cette variable n’est utilisée que si les variables RC_FILE et RES_FILE ne sont pas définies. N’oubliez pas de supprimer embed_manifest_exe et embed_manifest_dll de la variable CONFIG, sinon cela entrera en conflit avec celui généré par le compilateur.

QMAKE_TVOS_DEPLOYMENT_TARGET

Spécifie la version minimale absolue de tvOS prise en charge par l’application.

Pour plus d’informations, consultez la section « Spécification des versions iOS prises en charge ».

QMAKE_UIC_FLAGS

Cette variable sert à personnaliser la liste des options transmises à la User Interface Compiler dans chacune des règles de compilation où elle est utilisée.

QMAKE_WATCHOS_DEPLOYMENT_TARGET

Elle spécifie la version minimale absolue de watchOS prise en charge par l’application.

Pour plus d’informations, consultez la section « Expression des versions iOS prises en charge ».

QML_IMPORT_MAJOR_VERSION

Spécifie la version majeure à utiliser pour les enregistrements de types QML générés automatiquement. Pour plus d'informations, consultez la section « Définition des types QML à partir de C++ ».

QML_IMPORT_MINOR_VERSION

Lors de l'enregistrement automatique des types QML définis en C++, enregistrez une version supplémentaire du module en utilisant cette version mineure. En général, les versions mineures à enregistrer sont déduites à partir des méta-objets.

Vous pouvez utiliser cette variable si les méta-objets n’ont pas changé et que vous souhaitez tout de même importer un module QML avec un numéro de version mineure plus récent. Par exemple, les méta-objets d’ MyModule se situent au niveau 1.1, mais vous souhaitez importer le module sous le nom 1.3.

QML_IMPORT_VERSION

Spécifie QML_IMPORT_MAJOR_VERSION et QML_IMPORT_MINOR_VERSION sous la forme d’une chaîne de caractères représentant la version <major>.<minor>.

QML_IMPORT_NAME

Spécifie le nom du module à utiliser pour les enregistrements de types QML générés automatiquement. Pour plus d’informations, consultez la section « Définition de types QML à partir de C++ ».

QML_FOREIGN_METATYPES

Spécifie d’autres fichiers JSON contenant des métatypes à prendre en compte lors de la génération des fichiers qmltypes. Utilisez cette option lorsque des bibliothèques externes fournissent des types exposés à QML, soit directement, soit en tant que types de base ou propriétés d’autres types. Les types Qt sont automatiquement pris en compte et n’ont pas besoin d’être ajoutés ici.

QT

Spécifie les modules Qt utilisés par votre projet. Pour connaître la valeur à ajouter pour chaque module, consultez la documentation du module.

Au niveau de l’implémentation C++, l’utilisation d’un module Qt rend ses en-têtes disponibles pour inclusion et entraîne sa liaison au binaire.

Par défaut, ` QT ` contient ` core ` et ` gui`, ce qui garantit que les applications GUI standard peuvent être compilées sans configuration supplémentaire.

Si vous souhaitez compiler un projet sans le Qt GUI module, vous devez exclure la valeur « gui » à l’aide de l’opérateur « -= ». La ligne suivante permettra de compiler un projet Qt minimal :

QT -= gui # Only the core module is used.

Si votre projet est un plugin Qt Widgets Designer, utilisez la valeur uiplugin pour spécifier que le projet doit être compilé en tant que bibliothèque, mais avec une prise en charge spécifique des plugins pour Qt Widgets Designer. Pour plus d’informations, consultez la section « Compilation et installation du plugin ».

QTPLUGIN

Spécifie une liste de noms de plugins Qt statiques qui doivent être liés à une application afin qu’ils soient disponibles en tant que ressources intégrées.

qmake ajoute automatiquement les plugins généralement requis par les modules Qt utilisés (voir QT). Les paramètres par défaut sont optimisés pour offrir une expérience prête à l’emploi optimale. Consultez la section Plugins statiques pour obtenir la liste des plugins disponibles et découvrir comment remplacer la liaison automatique.

Cette variable n’a actuellement aucun effet lors de la liaison avec une version partagée/dynamique de Qt, ni lors de la liaison de bibliothèques. Elle pourra être utilisée ultérieurement pour le déploiement de plug-ins dynamiques.

QT_VERSION

Contient la version actuelle de Qt.

QT_MAJOR_VERSION

Contient la version majeure actuelle de Qt.

QT_MINOR_VERSION

Contient la version mineure actuelle de Qt.

QT_PATCH_VERSION

Contient la version de correctif actuelle de Qt.

RC_FILE

Windows uniquement. Spécifie le nom du fichier de ressources Windows (.rc) pour la cible. Voir Ajout de fichiers de ressources Windows.

RC_CODEPAGE

Windows uniquement. Spécifie la page de codes qui doit être indiquée dans un fichier .rc généré. Cette variable n'est utilisée que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

RC_DEFINES

Windows uniquement. qmake ajoute les valeurs de cette variable en tant que macros du préprocesseur RC (option /d). Si cette variable n'est pas définie, c'est la variable DEFINES qui est utilisée à la place.

RC_DEFINES += USE_MY_STUFF

RC_ICONS

Windows uniquement. Spécifie les icônes à inclure dans un fichier .rc généré. Cette variable n’est utilisée que si les variables RC_FILE et RES_FILE ne sont pas définies. Vous trouverez plus de détails sur la génération des fichiers .rc dans les Notes sur les plateformes.

RC_LANG

Windows uniquement. Spécifie la langue à indiquer dans un fichier .rc généré. Cette variable n'est utilisée que si la variable VERSION ou RC_ICONS est définie et que les variables RC_FILE et RES_FILE ne le sont pas.

RC_INCLUDEPATH

Spécifie les chemins d’inclusion transmis à l’ Resource Compiler.

RCC_DIR

Spécifie le répertoire dans lequel seront placés les fichiers de sortie de l'Resource Compiler de Qt.

Par exemple :

unix:RCC_DIR = ../myproject/resources
win32:RCC_DIR = c:/myproject/resources

REQUIRES

Spécifie une liste de valeurs qui sont évaluées comme des conditions. Si l'une des conditions est fausse, qmake ignore ce projet (et ses SUBDIRS) lors de la compilation.

RESOURCES

Spécifie le nom des fichiers de collection de ressources (qrc) pour la cible. Pour plus d’informations sur le fichier de collection de ressources, consultez la section « Le système de ressources Qt ».

RES_FILE

Windows uniquement. Spécifie le nom du fichier de sortie du Resource Compiler de ressources Windows pour cette cible. Voir RC_FILE et Ajout de fichiers de ressources Windows.

La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

SOURCES

Spécifie les noms de tous les fichiers source du projet.

Remarque sur les fichiers source inclus

Par défaut, QMake analyse les fichiers source à la recherche de dépendances et exclut automatiquement les fichiers .cpp inclus dans d’autres fichiers .cpp afin d’éviter les compilations en double et les erreurs de l’éditeur de liens. Cette exclusion automatique présente des limitations importantes :

• L'exclusion s'applique indépendamment des conditions de préprocesseur (#ifdef, #ifndef, etc.).
• Un fichier .cpp #included n’importe où dans le projet sera exclu de SOURCES, même si l’inclusion est conditionnelle.

Pour forcer la compilation des fichiers exclus, ajoutez ` CONFIG += compile_included_sources ` à votre fichier .pro. Vous pouvez également supprimer les fichiers inclus de `SOURCES` et vous assurer qu’ils ne sont compilés que via leur fichier d’inclusion. Cela s’applique à tous les fichiers dont l’extension figure dans `QMAKE_EXT_CPP`.

Par exemple :

SOURCES = myclass.cpp \
      login.cpp \
      mainwindow.cpp

Voir également HEADERS.

SUBDIRS

Cette variable, lorsqu’elle est utilisée avec le modèle subdirs, spécifie les noms de tous les sous-répertoires ou fichiers de projet contenant des parties du projet qui doivent être construites. Chaque sous-répertoire spécifié à l’aide de cette variable doit contenir son propre fichier de projet.

Il est recommandé que le fichier de projet de chaque sous-répertoire porte le même nom de base que le sous-répertoire lui-même, car cela permet d’omettre le nom du fichier. Par exemple, si le sous-répertoire s’appelle myapp, le fichier de projet dans ce répertoire doit s’appeler myapp.pro.

Vous pouvez également spécifier un chemin relatif vers un fichier .pro situé dans n'importe quel répertoire. Il est fortement recommandé de ne spécifier que des chemins situés dans le répertoire parent du projet actuel ou dans ses sous-répertoires.

Par exemple :

SUBDIRS = kernel \
          tools \
          myapp

Si vous devez vous assurer que les sous-répertoires sont compilés dans un ordre particulier, utilisez le modificateur .depends sur les éléments SUBDIRS concernés.

Par exemple :

SUBDIRS += my_executable my_library tests doc
my_executable.depends = my_library
tests.depends = my_executable

La configuration ci-dessus garantit que ` my_library ` est compilé avant ` my_executable ` et que ` my_executable ` est compilé avant ` tests`. Cependant, ` doc ` peut être compilé en parallèle avec les autres sous-répertoires, ce qui accélère le processus de compilation.

Outre la définition de l’ordre de compilation, il est possible de modifier le comportement par défaut de ` SUBDIRS ` en ajoutant des modificateurs supplémentaires aux éléments ` SUBDIRS `. Les modificateurs pris en charge sont :

Par exemple, définissez deux sous-répertoires, situés tous deux dans un répertoire différent de la valeur « SUBDIRS », et dont l’un doit être compilé avant l’autre :

SUBDIRS += my_executable my_library
my_executable.subdir = app
my_executable.depends = my_library
my_library.subdir = lib

TARGET

Spécifie le nom du fichier cible. Contient par défaut le nom de base du fichier de projet.

Par exemple :

TEMPLATE = app
TARGET = myapp
SOURCES = main.cpp

Le fichier de projet ci-dessus produirait un exécutable nommé myapp sous Unix et myapp.exe sous Windows.

TARGET_EXT

Spécifie l'extension de TARGET. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n'a que rarement besoin d'être modifiée.

TARGET_x

Spécifie l’extension de TARGET avec un numéro de version majeur. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

TARGET_x.y.z

Spécifie l’extension de TARGET avec un numéro de version. La valeur de cette variable est généralement gérée par qmake ou qmake.conf et n’a que rarement besoin d’être modifiée.

TEMPLATE

Spécifie le nom du modèle à utiliser lors de la génération du projet. Les valeurs autorisées sont :

Par exemple :

TEMPLATE = lib
SOURCES = main.cpp
TARGET = mylib

Le modèle peut être remplacé en spécifiant un nouveau type de modèle à l'aide de l'option de ligne de commande « -t ». Cela remplace le type de modèle une fois le fichier .pro traité. Avec les fichiers .pro qui utilisent le type de modèle pour déterminer la manière dont le projet est construit, il est nécessaire de déclarer « TEMPLATE » sur la ligne de commande plutôt que d'utiliser l'option « -t ».

TRANSLATIONS

Spécifie une liste de fichiers de traduction (.ts) contenant les traductions du texte de l’interface utilisateur dans des langues autres que la langue d’origine.

Les fichiers de traduction situés dans ` TRANSLATIONS ` seront traités à la fois par l'outil `lrelease` et par l'outil `lupdate`. Utilisez `EXTRA_TRANSLATIONS` si vous souhaitez que seul ` lrelease ` traite un fichier.

Vous pouvez utiliser CONFIG += lrelease pour compiler automatiquement les fichiers lors de la compilation, et CONFIG += lrelease embed_translations pour les rendre disponibles dans le système de ressources Qt.

Consultez le manuelQt Linguist pour plus d’informations sur l’internationalisation (i18n) et la localisation (l10n) avec Qt.

TR_EXCLUDE

Spécifie une liste de chemins (fichiers source, sous-répertoires et chemins d’inclusion C++) à exclure du traitement par lupdate. Les chemins peuvent contenir des caractères génériques. Les chemins relatifs sont considérés comme relatifs à _PRO_FILE_PWD_.

Par exemple, pour exclure des fichiers source :

SOURCES += main.cpp \
    excluded.cpp \
    3rdparty/sqlite3.h \
    3rdparty/sqlite3.c
TR_EXCLUDE += excluded.cpp 3rdparty/*

Pour exclure des sous-répertoires d’un projet SUBDIRS:

SUBDIRS += \
    libs \
    apps \
    tests
TR_EXCLUDE += tests

Pour accélérer l'analyseur C++ de lupdate, excluez les chemins d'inclusion :

linux {
    TR_EXCLUDE += /usr/include/boost/*
}

UI_DIR

Spécifie le répertoire dans lequel tous les fichiers intermédiaires générés par uic doivent être placés.

Par exemple :

unix:UI_DIR = ../myproject/ui
win32:UI_DIR = c:/myproject/ui

VERSION

Spécifie le numéro de version de l’application si le modèle ` app ` est spécifié, ou le numéro de version de la bibliothèque si le modèle ` lib ` est spécifié.

Sous Windows, déclenche la génération automatique d'un fichier .rc si les variables RC_FILE et RES_FILE ne sont pas définies. Le fichier .rc généré contiendra les entrées FILEVERSION et PRODUCTVERSION, qui seront renseignées avec le numéro de version majeure, mineure, le niveau de correctif et le numéro de build. Chaque nombre doit être compris entre 0 et 65 535. Vous trouverez plus de détails sur la génération des fichiers .rc dans les Notes sur la plate-forme.

Par exemple :

win32:VERSION = 1.2.3.4 # major.minor.patch.build
else:VERSION = 1.2.3    # major.minor.patch

VERSION_PE_HEADER

Windows uniquement. Spécifie le numéro de version que l’éditeur de liens Windows insère dans l’en-tête du fichier .exe ou .dll via l’option /VERSION. Seules les versions majeure et mineure peuvent être spécifiées. Si VERSION_PE_HEADER n’est pas défini, le système utilise par défaut les versions majeure et mineure de VERSION (si celle-ci est définie).

VERSION_PE_HEADER = 1.2

VER_MAJ

Spécifie le numéro de version majeure de la bibliothèque si le modèle « lib » est spécifié.

VER_MIN

Spécifie le numéro de version mineure de la bibliothèque si le modèle d'lib est spécifié.

VER_PAT

Spécifie le numéro de version de correctif de la bibliothèque si le modèle « lib » est spécifié.

VPATH

Indique à qmake où rechercher les fichiers qu’il ne parvient pas à ouvrir. Par exemple, si qmake recherche SOURCES et trouve une entrée qu’il ne parvient pas à ouvrir, il parcourt l’intégralité de la liste VPATH pour voir s’il peut trouver le fichier par lui-même.

Voir également DEPENDPATH.

WINDOWS_TARGET_PLATFORM_VERSION

Spécifie la version ciblée de Windows ; cela correspond à la balise WindowsTargetPlatformVersion dans les fichiers vcxproj.

Sous Windows pour ordinateurs de bureau, la valeur par défaut est celle de la variable d'environnement WindowsSDKVersion.

WINDOWS_TARGET_PLATFORM_MIN_VERSION

Spécifie la version minimale de la plate-forme Windows cible ; cela correspond à la balise WindowsTargetPlatformMinVersion dans les fichiers vcxproj.

La valeur par défaut est WINDOWS_TARGET_PLATFORM_VERSION.

YACCSOURCES

Spécifie une liste de fichiers source Yacc à inclure dans le projet. Toutes les dépendances, les en-têtes et les fichiers source seront automatiquement inclus dans le projet.

Par exemple :

YACCSOURCES = moc.y

_PRO_FILE_

Contient le chemin d'accès au fichier de projet utilisé.

Par exemple, la ligne suivante provoque l'affichage de l'emplacement du fichier de projet sur la console :

message($$_PRO_FILE_)

_PRO_FILE_PWD_

Contient le chemin d'accès au répertoire contenant le fichier de projet en cours d'utilisation.

Par exemple, la ligne suivante affiche l'emplacement du répertoire contenant le fichier de projet dans la console :

message($$_PRO_FILE_PWD_)