376 lines
15 KiB
Plaintext
376 lines
15 KiB
Plaintext
CONFIG *= thread
|
|
|
|
#handle defines
|
|
win32 {
|
|
contains(QT_CONFIG, shared) {
|
|
# this variable is read by qmake in qmake/generators/win32/msvc_vcproj.cpp
|
|
# function VcprojGenerator::initDeploymentTool()
|
|
QMAKE_DLL_PATHS += $$[QT_INSTALL_BINS/get]
|
|
}
|
|
}
|
|
CONFIG(release, debug|release):DEFINES += QT_NO_DEBUG
|
|
contains(QT_CONFIG, force_asserts):DEFINES += QT_FORCE_ASSERTS
|
|
no_keywords:DEFINES += QT_NO_KEYWORDS
|
|
plugin { #Qt plugins
|
|
static:DEFINES += QT_STATICPLUGIN
|
|
DEFINES += QT_PLUGIN
|
|
}
|
|
|
|
qtestlib {
|
|
warning("CONFIG+=qtestlib is deprecated. Use QT+=testlib instead.")
|
|
QT += testlib
|
|
}
|
|
qdbus {
|
|
warning("CONFIG+=qdbus is deprecated. Use QT+=dbus instead.")
|
|
QT += dbus
|
|
}
|
|
help {
|
|
warning("CONFIG+=help is deprecated. Use QT+=help instead.")
|
|
QT += help-private # sic!
|
|
}
|
|
designer {
|
|
warning("CONFIG+=designer is deprecated. Use QT+=designer instead.")
|
|
QT += designer
|
|
}
|
|
uitools {
|
|
warning("CONFIG+=uitools is deprecated. Use QT+=uitools instead.")
|
|
QT += uitools
|
|
}
|
|
qaxcontainer {
|
|
warning("CONFIG+=qaxcontainer is deprecated. Use QT+=axcontainer instead.")
|
|
QT += axcontainer
|
|
}
|
|
qaxserver {
|
|
warning("CONFIG+=qaxserver is deprecated. Use QT+=axserver instead.")
|
|
QT += axserver
|
|
}
|
|
|
|
# target variable, flag source variable
|
|
defineTest(qtProcessModuleFlags) {
|
|
for(flag, $$2) {
|
|
contains(flag, ^-.*): \
|
|
$$1 -= $$replace(flag, ^-, )
|
|
else: \
|
|
$$1 += $$flag
|
|
}
|
|
export($$1)
|
|
}
|
|
|
|
unset(using_privates)
|
|
var_sfx =
|
|
for(ever) {
|
|
# qmake variables cannot contain dashes, so normalize the names first
|
|
CLEAN_QT$$var_sfx = $$replace(QT$$var_sfx, -private$, _private)
|
|
# Topological resolution of modules based on their QT.<module>.depends variable
|
|
FULL_QT$$var_sfx = $$resolve_depends(CLEAN_QT$$var_sfx, "QT.")
|
|
# Finally actually add the modules
|
|
unset(BAD_QT)
|
|
for(QTLIB, FULL_QT$$var_sfx) {
|
|
MODULE_NAME = $$eval(QT.$${QTLIB}.name)
|
|
MODULE_INCLUDES = $$eval(QT.$${QTLIB}.includes)
|
|
MODULE_LIBS = $$eval(QT.$${QTLIB}.libs)
|
|
MODULE_CONFIG = $$eval(QT.$${QTLIB}.module_config)
|
|
|
|
isEmpty(MODULE_NAME) {
|
|
BAD_QT += $$QTLIB
|
|
next()
|
|
}
|
|
|
|
contains(MODULE_CONFIG, internal_module): \
|
|
using_privates = true
|
|
contains(MODULE_CONFIG, ltcg): \
|
|
CONFIG += link_ltcg
|
|
|
|
qtProcessModuleFlags(CONFIG, QT.$${QTLIB}.CONFIG)
|
|
qtProcessModuleFlags(DEFINES, QT.$${QTLIB}.DEFINES)
|
|
|
|
MODULE_INCLUDES -= $$QMAKE_DEFAULT_INCDIRS
|
|
MODULE_LIBS_ADD = $$MODULE_LIBS
|
|
MODULE_LIBS_ADD -= $$QMAKE_DEFAULT_LIBDIRS
|
|
|
|
LINKAGE =
|
|
contains(MODULE_CONFIG, lib_bundle) {
|
|
FRAMEWORK_INCLUDE = $${MODULE_LIBS}/$${MODULE_NAME}.framework/Headers
|
|
!qt_no_framework_direct_includes {
|
|
INCLUDEPATH *= $$FRAMEWORK_INCLUDE
|
|
}
|
|
contains(MODULE_CONFIG, internal_module): \
|
|
INCLUDEPATH += \
|
|
$$FRAMEWORK_INCLUDE/$$eval(QT.$${QTLIB}.VERSION) \
|
|
$$FRAMEWORK_INCLUDE/$$eval(QT.$${QTLIB}.VERSION)/$$MODULE_NAME
|
|
QMAKE_FRAMEWORKPATH *= $${MODULE_LIBS}
|
|
!contains(MODULE_CONFIG, no_link): \
|
|
LINKAGE += -framework $${MODULE_NAME}$${QT_LIBINFIX}
|
|
} else {
|
|
INCLUDEPATH *= $$MODULE_INCLUDES
|
|
}
|
|
|
|
# Only link to this module if a libs directory is set, else this is just a module
|
|
# to give access to sources or include files, and not for linking.
|
|
!isEmpty(MODULE_LIBS):!contains(MODULE_CONFIG, no_link) {
|
|
|
|
# Re-insert the major version in the library name (cf qt5LibraryTarget above)
|
|
# unless it's a framework build
|
|
!contains(MODULE_CONFIG, lib_bundle): \
|
|
MODULE_NAME ~= s,^Qt,Qt$$QT_MAJOR_VERSION,
|
|
|
|
isEmpty(LINKAGE) {
|
|
!isEmpty(MODULE_LIBS_ADD): \
|
|
LINKAGE = -L$$MODULE_LIBS_ADD
|
|
lib = $${MODULE_NAME}$${QT_LIBINFIX}$$qtPlatformTargetSuffix()
|
|
LINKAGE += -l$$lib
|
|
|
|
contains(MODULE_CONFIG, staticlib): \
|
|
PRE_TARGETDEPS *= $$MODULE_LIBS/$${QMAKE_PREFIX_STATICLIB}$${lib}.$${QMAKE_EXTENSION_STATICLIB}
|
|
}
|
|
|
|
LIBS$$var_sfx += $$LINKAGE
|
|
|
|
!isEmpty(QMAKE_LSB) {
|
|
!isEmpty(MODULE_LIBS_ADD): \
|
|
QMAKE_LFLAGS *= --lsb-libpath=$$MODULE_LIBS_ADD
|
|
QMAKE_LFLAGS *= --lsb-shared-libs=$${MODULE_NAME}$${QT_LIBINFIX}
|
|
QMAKE_LIBDIR *= /opt/lsb/lib
|
|
}
|
|
}
|
|
}
|
|
!isEmpty(BAD_QT):error("Unknown module(s) in QT$$var_sfx: $$replace(BAD_QT, _private$, -private)")
|
|
|
|
!isEmpty(var_sfx): break()
|
|
var_sfx = _PRIVATE
|
|
}
|
|
!isEmpty(using_privates):!no_private_qt_headers_warning:if(!debug_and_release|!build_pass) {
|
|
message("This project is using private headers and will therefore be tied to this specific Qt module build version.")
|
|
message("Running this project against other versions of the Qt modules may crash at any arbitrary point.")
|
|
message("This is not a bug, but a result of using Qt internals. You have been warned!")
|
|
}
|
|
|
|
qt_module_deps = $$CLEAN_QT $$CLEAN_QT_PRIVATE
|
|
qt_module_deps = $$resolve_depends(qt_module_deps, "QT.")
|
|
|
|
!no_qt_rpath:!static:contains(QT_CONFIG, rpath):!contains(QT_CONFIG, static):\
|
|
contains(qt_module_deps, core) {
|
|
relative_qt_rpath:!isEmpty(QMAKE_REL_RPATH_BASE):contains(INSTALLS, target):\
|
|
isEmpty(target.files):isEmpty(target.commands):isEmpty(target.extra) {
|
|
mac {
|
|
if(equals(TEMPLATE, app):app_bundle)|\
|
|
if(equals(TEMPLATE, lib):plugin:plugin_bundle) {
|
|
ios: binpath = $$target.path/$${TARGET}.app
|
|
else: binpath = $$target.path/$${TARGET}.app/Contents/MacOS
|
|
} else: equals(TEMPLATE, lib):!plugin:lib_bundle {
|
|
binpath = $$target.path/$${TARGET}.framework/Versions/Current
|
|
} else {
|
|
binpath = $$target.path
|
|
}
|
|
} else {
|
|
binpath = $$target.path
|
|
}
|
|
# NOT the /dev property, as INSTALLS use host paths
|
|
QMAKE_RPATHDIR += $$relative_path($$[QT_INSTALL_LIBS], $$binpath)
|
|
} else {
|
|
QMAKE_RPATHDIR += $$[QT_INSTALL_LIBS/dev]
|
|
}
|
|
}
|
|
|
|
!isEmpty(QMAKE_LFLAGS_RPATHLINK):!contains(QT_CONFIG, static) {
|
|
# -rpath-link is used by the linker to find dependencies of dynamic
|
|
# libraries which were NOT specified on the command line.
|
|
# This means that paths of direct dependencies (QT & QT_PRIVATE)
|
|
# don't need to be listed, unlike their private dependencies' paths.
|
|
privdep = $$resolve_depends(qt_module_deps, "QT.", ".depends" ".run_depends")
|
|
privdep -= $$qt_module_deps
|
|
rpaths =
|
|
for(dep, privdep): \
|
|
rpaths += $$eval(QT.$${dep}.libs)
|
|
QMAKE_RPATHLINKDIR *= $$unique(rpaths)
|
|
}
|
|
|
|
# static builds: link qml import plugins into the app.
|
|
contains(qt_module_deps, qml): \
|
|
contains(QT_CONFIG, static):contains(TEMPLATE, .*app):!host_build:!no_import_scan {
|
|
!isEmpty(QTREPOS) {
|
|
for (qrep, QTREPOS): \
|
|
exists($$qrep/qml): \
|
|
QMLPATHS += $$qrep/qml
|
|
} else {
|
|
QMLPATHS += $$[QT_INSTALL_QML/get]
|
|
}
|
|
|
|
# run qmlimportscanner
|
|
qtPrepareTool(QMLIMPORTSCANNER, qmlimportscanner, , system)
|
|
for (QMLPATH, QMLPATHS): \
|
|
IMPORTPATHS += -importPath $$QMLPATH
|
|
|
|
#message(run $$QMLIMPORTSCANNER $$_PRO_FILE_PWD_ $$IMPORTPATHS)
|
|
JSON = $$system($$QMLIMPORTSCANNER $$_PRO_FILE_PWD_ $$IMPORTPATHS)
|
|
|
|
parseJson(JSON, IMPORTS)| error("Failed to parse qmlimportscanner output.")
|
|
|
|
!isEmpty(IMPORTS._KEYS_) {
|
|
# add import plugins to LIBS line
|
|
for (key, IMPORTS._KEYS_) {
|
|
PATH = $$eval(IMPORTS.$${key}.path)
|
|
PLUGIN = $$eval(IMPORTS.$${key}.plugin)
|
|
!isEmpty(PATH):!isEmpty(PLUGIN): LIBS *= -L$$PATH -l$${PLUGIN}$$qtPlatformTargetSuffix()
|
|
}
|
|
|
|
# create qml_plugin_import.cpp
|
|
IMPORT_FILE_CONT = \
|
|
"// This file is autogenerated by qmake. It imports static plugin classes for" \
|
|
"// static plugins used by QML imports." \
|
|
"$${LITERAL_HASH}include <QtPlugin>"
|
|
for (key, IMPORTS._KEYS_) {
|
|
PLUGIN = $$eval(IMPORTS.$${key}.plugin)
|
|
CLASSNAME = $$eval(IMPORTS.$${key}.classname)
|
|
!isEmpty(PLUGIN) {
|
|
!isEmpty(CLASSNAME) {
|
|
!contains(ADDED_IMPORTS, $$PLUGIN) {
|
|
ADDED_IMPORTS += $$PLUGIN
|
|
IMPORT_FILE_CONT += "Q_IMPORT_PLUGIN($$CLASSNAME)"
|
|
}
|
|
} else {
|
|
error("Plugin $$PLUGIN is missing a classname entry, please add one to the qmldir file.")
|
|
}
|
|
}
|
|
}
|
|
QML_IMPORT_CPP = $$OUT_PWD/$$lower($$basename(TARGET))_qml_plugin_import.cpp
|
|
write_file($$QML_IMPORT_CPP, IMPORT_FILE_CONT)|error("Aborting.")
|
|
GENERATED_SOURCES += $$QML_IMPORT_CPP
|
|
QMAKE_DISTCLEAN += $$QML_IMPORT_CPP
|
|
|
|
# copy qml files. this part is platform spesific.
|
|
mac {
|
|
osx {
|
|
# Note: user can override QMAKE_BUNDLE_QML from pro file to change target bundle path
|
|
isEmpty(QMAKE_QML_BUNDLE_PATH):QMAKE_QML_BUNDLE_PATH = "Resources/qt_qml"
|
|
qmlTargetPath = $$OUT_PWD/$${TARGET}.app/Contents/$$QMAKE_QML_BUNDLE_PATH
|
|
qtconfTargetPath = $$OUT_PWD/$${TARGET}.app/Contents/Resources/qt.conf
|
|
} else {
|
|
# iOS: flat bundle layout (no Contents/Resources)
|
|
isEmpty(QMAKE_QML_BUNDLE_PATH):QMAKE_QML_BUNDLE_PATH = "qt_qml"
|
|
qmlTargetPath = $CODESIGNING_FOLDER_PATH/$$QMAKE_QML_BUNDLE_PATH
|
|
qtconfTargetPath = $CODESIGNING_FOLDER_PATH/qt.conf
|
|
}
|
|
|
|
# set import path in qt.conf to point to the bundeled qml:
|
|
QT_CONF_CONTENTS = \
|
|
"[Paths]" \
|
|
"Imports = $$QMAKE_QML_BUNDLE_PATH" \
|
|
"Qml2Imports = $$QMAKE_QML_BUNDLE_PATH"
|
|
write_file("$$OUT_PWD/qt.conf", QT_CONF_CONTENTS)|error("Aborting.")
|
|
|
|
# write qt.conf and copy each qml import dir into the bundle.
|
|
# But strip away archives and other files that are not needed:
|
|
!isEmpty(QMAKE_POST_LINK): QMAKE_POST_LINK += ";"
|
|
QMAKE_POST_LINK += \
|
|
"cp $$OUT_PWD/qt.conf $$qtconfTargetPath; " \
|
|
"test -d $$qmlTargetPath && rm -r $$qmlTargetPath; " \
|
|
"mkdir -p $$qmlTargetPath && " \
|
|
"for p in $$QMLPATHS; do" \
|
|
"rsync -r --exclude='*.a' --exclude='*.prl' --exclude='*.qmltypes' "
|
|
macx-xcode: QMAKE_POST_LINK += "$p/ $$qmlTargetPath; done"
|
|
else: QMAKE_POST_LINK += "\$\$p/ $$qmlTargetPath; done"
|
|
}
|
|
}
|
|
}
|
|
|
|
!import_qpa_plugin {
|
|
warning("CONFIG-=import_qpa_plugin is deprecated. Use QTPLUGIN.platforms=- instead.")
|
|
QTPLUGIN.platforms = -
|
|
} else: qpa_minimal_plugin {
|
|
warning("CONFIG+=qpa_minimal_plugin is deprecated. Use QTPLUGIN.platforms=qminimal instead.")
|
|
QTPLUGIN.platforms = qminimal
|
|
}
|
|
|
|
contains(TEMPLATE, .*app) {
|
|
autoplugs =
|
|
for (qtmod, qt_module_deps) {
|
|
for (ptype, QT.$${qtmod}.plugin_types) {
|
|
isEmpty(QTPLUGIN.$$ptype) {
|
|
for (plug, QT_PLUGINS) {
|
|
equals(QT_PLUGIN.$${plug}.TYPE, $$ptype) {
|
|
for (dep, QT_PLUGIN.$${plug}.EXTENDS) {
|
|
!contains(qt_module_deps, $$dep) {
|
|
plug =
|
|
break()
|
|
}
|
|
}
|
|
autoplugs += $$plug
|
|
}
|
|
}
|
|
} else {
|
|
plug = $$eval(QTPLUGIN.$$ptype)
|
|
!equals(plug, -): \
|
|
autoplugs += $$plug
|
|
}
|
|
}
|
|
}
|
|
manualplugs = $$QTPLUGIN
|
|
manualplugs -= $$autoplugs
|
|
QTPLUGIN -= $$manualplugs
|
|
!isEmpty(QTPLUGIN): \
|
|
warning("Redundant entries in QTPLUGIN: $$QTPLUGIN")
|
|
QTPLUGIN = $$manualplugs $$autoplugs
|
|
}
|
|
|
|
QT_PLUGIN_VERIFY = DEPLOYMENT_PLUGIN
|
|
contains(QT_CONFIG, static) {
|
|
QT_PLUGIN_VERIFY += QTPLUGIN
|
|
force_import_plugins|contains(TEMPLATE, .*app) {
|
|
import_plugins:!isEmpty(QTPLUGIN) {
|
|
IMPORT_FILE_CONT = \
|
|
"// This file is autogenerated by qmake. It imports static plugin classes for" \
|
|
"// static plugins specified using QTPLUGIN and QT_PLUGIN_CLASS.<plugin> variables." \
|
|
"$${LITERAL_HASH}include <QtPlugin>"
|
|
for(IMPORT_PLUG, $$list($$unique(QTPLUGIN))) {
|
|
PLUG_CLASS = $$eval(QT_PLUGIN.$${IMPORT_PLUG}.CLASS_NAME)
|
|
!isEmpty(PLUG_CLASS): \
|
|
IMPORT_FILE_CONT += "Q_IMPORT_PLUGIN($$PLUG_CLASS)"
|
|
else: \
|
|
warning("Plugin class name could not be determined for $$IMPORT_PLUG plugin.")
|
|
}
|
|
IMPORT_CPP = $$OUT_PWD/$$lower($$basename(TARGET))_plugin_import.cpp
|
|
write_file($$IMPORT_CPP, IMPORT_FILE_CONT)|error("Aborting.")
|
|
GENERATED_SOURCES += $$IMPORT_CPP
|
|
QMAKE_DISTCLEAN += $$IMPORT_CPP
|
|
}
|
|
}
|
|
}
|
|
|
|
for(QT_CURRENT_VERIFY, $$list($$QT_PLUGIN_VERIFY)) {
|
|
for(QTPLUG, $$list($$lower($$unique($$QT_CURRENT_VERIFY)))) {
|
|
# Check if the plugin is known to Qt. We can use this to determine
|
|
# the plugin path. Unknown plugins must rely on the default link path.
|
|
QT_PLUGINPATH = $$eval(QT_PLUGIN.$${QTPLUG}.TYPE)
|
|
|
|
# Generate the plugin linker line
|
|
QT_LINKAGE = -l$${QTPLUG}$$qtPlatformTargetSuffix()
|
|
|
|
# Only link against plugin in static builds
|
|
isEqual(QT_CURRENT_VERIFY, QTPLUGIN) {
|
|
!isEmpty(QT_PLUGINPATH) {
|
|
plugpath = $$eval(QT_PLUGIN.$${QTPLUG}.PATH)
|
|
isEmpty(plugpath): \
|
|
plugpath = $$[QT_INSTALL_PLUGINS/get]
|
|
LIBS *= -L$$plugpath/$$QT_PLUGINPATH
|
|
}
|
|
LIBS += $$QT_LINKAGE
|
|
# if the plugin is linked statically there is no need to deploy it
|
|
DEPLOYMENT_PLUGIN -= $$QT_CURRENT_VERIFY
|
|
}
|
|
|
|
# The following block is currently broken, because qt_plugin_XXX.prf files
|
|
# are not generated for dynamic builds.
|
|
false:isEqual(QT_CURRENT_VERIFY, DEPLOYMENT_PLUGIN):shared:if(wince*|winrt) {
|
|
QT_ITEM =
|
|
debug: QT_ITEM = $${QTPLUG}d4.dll
|
|
else: QT_ITEM = $${QTPLUG}4.dll
|
|
|
|
qt_additional_plugin_$${QTPLUG}.files = $$[QT_INSTALL_PLUGINS/get]/$${QT_PLUGINPATH}/$${QT_ITEM}
|
|
qt_additional_plugin_$${QTPLUG}.path = $${QT_PLUGINPATH}
|
|
|
|
INSTALLS *= qt_additional_plugin_$${QTPLUG}
|
|
}
|
|
}
|
|
}
|