summaryrefslogtreecommitdiff
path: root/mkspecs/features/qt.prf
blob: 634757a653582ac004785a847d835a899e018d2b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
CONFIG *= thread

#handle defines
win32 {
   qtConfig(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
qtConfig(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_MODULE = $$eval(QT.$${QTLIB}.module)
        MODULE_INCLUDES = $$eval(QT.$${QTLIB}.includes)
        MODULE_LIBS = $$eval(QT.$${QTLIB}.libs)
        MODULE_FRAMEWORKS = $$eval(QT.$${QTLIB}.frameworks)
        MODULE_USES = $$eval(QT.$${QTLIB}.uses)
        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

        !contains(MODULE_CONFIG, v2) {
            # Backwards compatibility with pre-5.6 module .pri files

            contains(MODULE_CONFIG, lib_bundle) {
                MODULE_FRAMEWORKS = $$MODULE_LIBS
                inc = $$MODULE_LIBS/$${MODULE_NAME}.framework/Headers
                MODULE_INCLUDES = $$inc
                contains(MODULE_CONFIG, internal_module): \
                    MODULE_INCLUDES += \
                        $$inc/$$eval(QT.$${QTLIB}.VERSION) \
                        $$inc/$$eval(QT.$${QTLIB}.VERSION)/$$MODULE_NAME
            } else {
                # Re-insert the major version in the library name (cf qt5LibraryTarget above)
                MODULE_NAME ~= s,^Qt,Qt$$QT_MAJOR_VERSION,
            }

            # 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): \
                MODULE_MODULE = $${MODULE_NAME}$${QT_LIBINFIX}
        }

        # Frameworks shouldn't need include paths, but much code does not use
        # module-qualified #includes, so by default we add paths which point
        # directly into the frameworks. Private modules have somewhat convoluted
        # header paths, so adding them is necessary in every case.
        !if(contains(MODULE_CONFIG, lib_bundle):qt_no_framework_direct_includes) \
                |contains(MODULE_CONFIG, internal_module): \
            INCLUDEPATH *= $$MODULE_INCLUDES
        QMAKE_FRAMEWORKPATH *= $$MODULE_FRAMEWORKS
        !isEmpty(MODULE_MODULE) {
            contains(MODULE_CONFIG, lib_bundle) {
                LIBS$$var_sfx += -framework $$MODULE_MODULE
            } else {
                !isEmpty(MODULE_LIBS_ADD): \
                    LIBS$$var_sfx += -L$$MODULE_LIBS_ADD

                lib = $$MODULE_MODULE$$qtPlatformTargetSuffix()
                LIBS$$var_sfx += -l$$lib

                contains(MODULE_CONFIG, staticlib): \
                    PRE_TARGETDEPS *= $$MODULE_LIBS/$${QMAKE_PREFIX_STATICLIB}$${lib}.$${QMAKE_EXTENSION_STATICLIB}

                !isEmpty(QMAKE_LSB) {
                    !isEmpty(MODULE_LIBS_ADD): \
                        QMAKE_LFLAGS *= --lsb-libpath=$$MODULE_LIBS_ADD
                    QMAKE_LFLAGS *= --lsb-shared-libs=$$lib
                    QMAKE_LIBDIR *= /opt/lsb/lib
                }
            }
        }
        QMAKE_USE$$var_sfx += $$MODULE_USES
        # Add capabilities as defined by modules used in the project
        winrt {
            MODULE_WINRT_CAPABILITIES = $$eval(QT.$${QTLIB}.winrt_capabilities)
            !isEmpty(MODULE_WINRT_CAPABILITIES): \
                WINRT_MANIFEST.capabilities_default += $$MODULE_WINRT_CAPABILITIES
            MODULE_WINRT_CAPABILITIES_DEVICE = $$eval(QT.$${QTLIB}.winrt_capabilities_device)
            !isEmpty(MODULE_WINRT_CAPABILITIES_DEVICE): \
                WINRT_MANIFEST.capabilities_device_default += $$MODULE_WINRT_CAPABILITIES_DEVICE
        }
    }
    !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:!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:qtConfig(rpath):!qtConfig(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) {
        # NOT the /dev property, as INSTALLS use host paths
        QMAKE_RPATHDIR += $$relative_path($$[QT_INSTALL_LIBS], $$qtRelativeRPathBase())
    } else {
        QMAKE_RPATHDIR += $$[QT_INSTALL_LIBS/dev]
    }
}

!isEmpty(QMAKE_LFLAGS_RPATHLINK):!qtConfig(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): \
        qtConfig(static):contains(TEMPLATE, .*app):!host_build:!no_import_scan {
    exists($$[QT_INSTALL_QML/get]): \
        QMLPATHS *= $$[QT_INSTALL_QML/get]

    # run qmlimportscanner
    qtPrepareTool(QMLIMPORTSCANNER, qmlimportscanner, , system)
    for (QMLPATH, QMLPATHS): \
        IMPORTPATHS += -importPath $$system_quote($$QMLPATH)

    #message(run $$QMLIMPORTSCANNER $$_PRO_FILE_PWD_  $$IMPORTPATHS)
    JSON = $$system($$QMLIMPORTSCANNER $$system_quote($$_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()
        GENERATED_SOURCES += $$QML_IMPORT_CPP
        QMAKE_DISTCLEAN += $$QML_IMPORT_CPP

        # copy qml files. this part is platform spesific.
        mac {
            !shallow_bundle {
                # 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 {
                # shallow 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()

            # 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 $$shell_quote($$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) {
            nptype = $$replace(ptype, [-/], _)
            isEmpty(QTPLUGIN.$$nptype) {
                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.$$nptype)
                !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
qtConfig(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()
            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: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}
        }
    }
}