]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | # Copyright 2002-2006 Vladimir Prus |
2 | # Copyright 2005 Alo Sarv | |
3 | # Copyright 2005-2012 Juergen Hunold | |
4 | # | |
5 | # Distributed under the Boost Software License, Version 1.0. (See | |
6 | # accompanying file LICENSE_1_0.txt or copy at | |
7 | # http://www.boost.org/LICENSE_1_0.txt) | |
8 | ||
9 | # Qt5 library support module | |
10 | # | |
11 | # The module attempts to auto-detect QT installation location from QTDIR | |
12 | # environment variable; failing that, installation location can be passed as | |
13 | # argument: | |
14 | # | |
15 | # toolset.using qt5 : /usr/local/Trolltech/Qt-5.0.0 ; | |
16 | # | |
17 | # The module supports code generation from .ui and .qrc files, as well as | |
18 | # running the moc preprocessor on headers. Note that you must list all your | |
19 | # moc-able headers in sources. | |
20 | # | |
21 | # Example: | |
22 | # | |
23 | # exe myapp : myapp.cpp myapp.h myapp.ui myapp.qrc | |
24 | # /qt5//QtGui /qt5//QtNetwork ; | |
25 | # | |
26 | # It's also possible to run moc on cpp sources: | |
27 | # | |
28 | # import cast ; | |
29 | # | |
30 | # exe myapp : myapp.cpp [ cast _ moccable-cpp : myapp.cpp ] /qt5//QtGui ; | |
31 | # | |
32 | # When moccing source file myapp.cpp you need to include "myapp.moc" from | |
33 | # myapp.cpp. When moccing .h files, the output of moc will be automatically | |
34 | # compiled and linked in, you don't need any includes. | |
35 | # | |
36 | # This is consistent with Qt guidelines: | |
37 | # http://qt-project.org/doc/qt-5.0/moc.html | |
38 | ||
39 | # The .qrc processing utility supports various command line option (see | |
40 | # http://qt-project.org/doc/qt-5.0/rcc.html for a complete list). The | |
41 | # module provides default arguments for the "output file" and | |
42 | # "initialization function name" options. Other options can be set through | |
43 | # the <rccflags> build property. E.g. if you wish the compression settings | |
44 | # to be more aggressive than the defaults, you can apply them too all .qrc | |
45 | # files like this: | |
46 | # | |
47 | # project my-qt-project : | |
48 | # requirements | |
49 | # <rccflags>"-compress 9 -threshold 10" | |
50 | # ; | |
51 | # | |
52 | # Of course, this property can also be specified on individual targets. | |
53 | ||
54 | ||
55 | import modules ; | |
56 | import feature ; | |
57 | import errors ; | |
58 | import type ; | |
59 | import "class" : new ; | |
60 | import generators ; | |
61 | import project ; | |
62 | import toolset : flags ; | |
63 | import os ; | |
64 | import virtual-target ; | |
65 | import scanner ; | |
66 | ||
67 | # The Qt version used for requirements | |
68 | # Valid are <qt>5.0 or <qt>5.1.0 | |
69 | # Auto-detection via qmake sets '<qt>major.minor.patch' | |
70 | feature.feature qt5 : : propagated ; | |
71 | ||
72 | # Extra flags for rcc | |
73 | # $TODO: figure out how to declare this only once | |
74 | # feature.feature rccflags : : free ; | |
75 | ||
76 | project.initialize $(__name__) ; | |
77 | project qt5 ; | |
78 | ||
79 | # Save the project so that we tolerate 'import + using' combo. | |
80 | .project = [ project.current ] ; | |
81 | ||
82 | # Helper utils for easy debug output | |
83 | if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ] | |
84 | { | |
85 | .debug-configuration = TRUE ; | |
86 | } | |
87 | ||
88 | local rule debug-message ( message * ) | |
89 | { | |
90 | if $(.debug-configuration) = TRUE | |
91 | { | |
11fdf7f2 | 92 | ECHO notice\: "[qt5-cfg]" $(message) ; |
7c673cae FG |
93 | } |
94 | } | |
95 | ||
96 | # Capture qmake output line by line | |
97 | local rule read-output ( content ) | |
98 | { | |
99 | local lines ; | |
100 | local nl = " | |
101 | " ; | |
102 | local << = "([^$(nl)]*)[$(nl)](.*)" ; | |
103 | local line+ = [ MATCH "$(<<)" : "$(content)" ] ; | |
104 | while $(line+) | |
105 | { | |
106 | lines += $(line+[1]) ; | |
107 | line+ = [ MATCH "$(<<)" : "$(line+[2])" ] ; | |
108 | } | |
109 | return $(lines) ; | |
110 | } | |
111 | ||
112 | # Capture Qt version from qmake | |
113 | local rule check-version ( bin_prefix ) | |
114 | { | |
115 | full-cmd = $(bin_prefix)"/qmake -v" ; | |
116 | debug-message Running '$(full-cmd)' ; | |
117 | local output = [ SHELL $(full-cmd) ] ; | |
118 | for line in [ read-output $(output) ] | |
119 | { | |
120 | # Parse the output to get all the results. | |
121 | if [ MATCH "QMake" : $(line) ] | |
122 | { | |
123 | # Skip first line of output | |
124 | } | |
125 | else | |
126 | { | |
127 | temp = [ MATCH "([0-9]*)\\.([0-9]*)\\.([0-9]*)" : $(line) ] ; | |
128 | } | |
129 | } | |
130 | return $(temp) ; | |
131 | } | |
132 | ||
133 | # Validate the version string and extract the major/minor part we care about. | |
134 | # | |
135 | local rule split-version ( version ) | |
136 | { | |
11fdf7f2 | 137 | local major-minor = [ MATCH "^([0-9]+)\.([0-9]+)(.*)$" : $(version) : 1 2 3 ] ; |
7c673cae FG |
138 | if ! $(major-minor[2]) || $(major-minor[3]) |
139 | { | |
140 | ECHO "Warning: 'using qt' expects a two part (major, minor) version number; got" $(version) instead ; | |
141 | ||
142 | # Add a zero to account for the missing digit if necessary. | |
143 | major-minor += 0 ; | |
144 | } | |
145 | ||
146 | return $(major-minor[1]) $(major-minor[2]) ; | |
147 | } | |
148 | ||
149 | # Initialize the QT support module. | |
150 | # Parameters: | |
151 | # - 'prefix' parameter tells where Qt is installed. | |
152 | # - 'version' optional version of Qt, else autodetected via 'qmake -v' | |
153 | # - 'condition' optional requirements | |
154 | # - 'namespace' optional support for configure -qtnamespace | |
155 | # - 'infix' optional support for configure -qtlibinfix | |
156 | # - 'full_bin' optional full path to Qt binaries (qmake,moc,uic,rcc) | |
157 | # - 'full_inc' optional full path to Qt top-level include directory | |
158 | # - 'full_lib' optional full path to Qt library directory | |
159 | rule init ( prefix : version ? : condition * : namespace ? : infix ? : full_bin ? : full_inc ? : full_lib ? ) | |
160 | { | |
161 | project.push-current $(.project) ; | |
162 | ||
163 | debug-message "==== Configuring Qt ... ====" ; | |
164 | for local v in version prefix condition namespace infix full_bin full_inc full_lib | |
165 | { | |
166 | if $($(v)) | |
167 | { | |
11fdf7f2 | 168 | debug-message " user-specified $(v):" '$($(v))' ; |
7c673cae FG |
169 | } |
170 | } | |
171 | ||
172 | # Needed as default value | |
173 | .prefix = $(prefix) ; | |
174 | ||
175 | # pre-build paths to detect reinitializations changes | |
176 | local inc_prefix lib_prefix bin_prefix ; | |
177 | if $(full_inc) | |
178 | { | |
179 | inc_prefix = $(full_inc) ; | |
180 | } | |
181 | else | |
182 | { | |
183 | inc_prefix = $(prefix)/include ; | |
184 | } | |
185 | if $(full_lib) | |
186 | { | |
187 | lib_prefix = $(full_lib) ; | |
188 | } | |
189 | else | |
190 | { | |
191 | lib_prefix = $(prefix)/lib ; | |
192 | } | |
193 | if $(full_bin) | |
194 | { | |
195 | bin_prefix = $(full_bin) ; | |
196 | } | |
197 | else | |
198 | { | |
199 | bin_prefix = $(prefix)/bin ; | |
200 | } | |
201 | ||
202 | # Globally needed variables | |
203 | .incprefix = $(inc_prefix) ; | |
204 | .libprefix = $(lib_prefix) ; | |
205 | .binprefix = $(bin_prefix) ; | |
206 | ||
207 | if ! $(.initialized) | |
208 | { | |
209 | # Make sure this is initialised only once | |
210 | .initialized = true ; | |
211 | ||
212 | # Generates cpp files from header files using "moc" tool | |
213 | generators.register-standard qt5.moc : H : CPP(moc_%) : <allow>qt5 ; | |
214 | ||
215 | # The OBJ result type is a fake, 'H' will be really produced. See | |
216 | # comments on the generator class, defined below the 'init' function. | |
217 | generators.register [ new uic-5-generator qt5.uic : UI : OBJ : | |
218 | <allow>qt5 ] ; | |
219 | ||
220 | # The OBJ result type is a fake here too. | |
221 | generators.register [ new moc-h-5-generator | |
222 | qt5.moc.inc : MOCCABLE5_CPP : OBJ : <allow>qt5 ] ; | |
223 | ||
224 | generators.register [ new moc-inc-5-generator | |
225 | qt5.moc.inc : MOCCABLE5_H : OBJ : <allow>qt5 ] ; | |
226 | ||
227 | # Generates .cpp files from .qrc files. | |
228 | generators.register-standard qt5.rcc : QRC : CPP(qrc_%) : <allow>qt5 ; | |
229 | ||
230 | # dependency scanner for wrapped files. | |
231 | type.set-scanner QRC : qrc-5-scanner ; | |
232 | ||
92f5a8d4 | 233 | # Save value of first occurring prefix |
7c673cae FG |
234 | .PREFIX = $(prefix) ; |
235 | } | |
236 | ||
237 | if $(version) | |
238 | { | |
239 | major-minor = [ split-version $(version) ] ; | |
240 | version = $(major-minor:J=.) ; | |
241 | } | |
242 | else | |
243 | { | |
244 | version = [ check-version $(bin_prefix) ] ; | |
245 | if $(version) | |
246 | { | |
247 | version = $(version:J=.) ; | |
248 | } | |
249 | debug-message Detected version '$(version)' ; | |
250 | } | |
251 | ||
252 | local target-requirements = $(condition) ; | |
253 | ||
254 | # Add the version, if any, to the target requirements. | |
255 | if $(version) | |
256 | { | |
257 | if ! $(version) in [ feature.values qt5 ] | |
258 | { | |
259 | feature.extend qt5 : $(version) ; | |
260 | } | |
261 | target-requirements += <qt5>$(version:E=default) ; | |
262 | } | |
263 | ||
264 | local target-os = [ feature.get-values target-os : $(condition) ] ; | |
265 | if ! $(target-os) | |
266 | { | |
267 | target-os ?= [ feature.defaults target-os ] ; | |
268 | target-os = $(target-os:G=) ; | |
269 | target-requirements += <target-os>$(target-os) ; | |
270 | } | |
271 | ||
272 | # Build exact requirements for the tools | |
273 | local tools-requirements = $(target-requirements:J=/) ; | |
274 | ||
275 | debug-message "Details of this Qt configuration:" ; | |
276 | debug-message " prefix: " '$(prefix:E=<empty>)' ; | |
277 | debug-message " binary path: " '$(bin_prefix:E=<empty>)' ; | |
278 | debug-message " include path:" '$(inc_prefix:E=<empty>)' ; | |
279 | debug-message " library path:" '$(lib_prefix:E=<empty>)' ; | |
280 | debug-message " target requirements:" '$(target-requirements)' ; | |
281 | debug-message " tool requirements: " '$(tools-requirements)' ; | |
282 | ||
283 | # setup the paths for the tools | |
284 | toolset.flags qt5.moc .BINPREFIX $(tools-requirements) : $(bin_prefix) ; | |
285 | toolset.flags qt5.rcc .BINPREFIX $(tools-requirements) : $(bin_prefix) ; | |
286 | toolset.flags qt5.uic .BINPREFIX $(tools-requirements) : $(bin_prefix) ; | |
287 | ||
288 | # TODO: 2009-02-12: Better support for directories | |
289 | # Most likely needed are separate getters for: include,libraries,binaries and sources. | |
290 | toolset.flags qt5.directory .PREFIX $(tools-requirements) : $(prefix) ; | |
291 | ||
292 | # Test for a buildable Qt. | |
293 | if [ glob $(.prefix)/Jamroot ] | |
294 | { | |
295 | .bjam-qt = true | |
296 | ||
297 | # this will declare QtCore (and qtmain on <target-os>windows) | |
298 | add-shared-library QtCore ; | |
299 | } | |
300 | else | |
301 | # Setup common pre-built Qt. | |
302 | # Special setup for QtCore on which everything depends | |
303 | { | |
304 | local link = [ feature.get-values link : $(condition) ] ; | |
305 | ||
306 | local usage-requirements = | |
307 | <include>$(.incprefix) | |
308 | <library-path>$(.libprefix) | |
309 | <threading>multi | |
310 | <allow>qt5 ; | |
311 | ||
312 | if $(link) in shared | |
313 | { | |
314 | usage-requirements += <dll-path>$(.libprefix) ; | |
315 | usage-requirements += <target-os>windows:<dll-path>$(.binprefix) ; | |
316 | } | |
317 | ||
318 | local suffix ; | |
319 | ||
320 | # debug versions on unix have to be built | |
321 | # separately and therefore have no suffix. | |
322 | .infix_version = "" ; | |
323 | .suffix_debug = "" ; | |
324 | ||
325 | # Control flag for auto-configuration of the debug libraries. | |
326 | # This setup requires Qt 'configure -debug-and-release'. | |
327 | # Only available on some platforms. | |
328 | # ToDo: 2009-02-12: Maybe throw this away and | |
329 | # require separate setup with <variant>debug as condition. | |
330 | .have_separate_debug = FALSE ; | |
331 | ||
332 | # Setup other platforms | |
333 | if $(target-os) in windows cygwin | |
334 | { | |
335 | .have_separate_debug = TRUE ; | |
336 | ||
337 | # On NT, the libs have "d" suffix in debug builds. | |
338 | .suffix_debug = "d" ; | |
339 | ||
340 | .infix_version = "5" ; | |
341 | ||
342 | # On Windows we must link against the qtmain library | |
343 | lib qtmain | |
344 | : # sources | |
345 | : # requirements | |
346 | <name>qtmain$(.suffix_debug) | |
347 | <variant>debug | |
348 | $(target-requirements) | |
349 | ; | |
350 | ||
351 | lib qtmain | |
352 | : # sources | |
353 | : # requirements | |
354 | <name>qtmain | |
355 | $(target-requirements) | |
356 | ; | |
357 | } | |
358 | else if $(target-os) = darwin | |
359 | { | |
360 | # On MacOS X, both debug and release libraries are available. | |
361 | .suffix_debug = "_debug" ; | |
362 | ||
363 | .have_separate_debug = TRUE ; | |
364 | ||
365 | alias qtmain ; | |
366 | } | |
367 | else | |
368 | { | |
369 | alias qtmain : : $(target-requirements) ; | |
370 | .infix_version = "5" ; | |
371 | } | |
372 | ||
373 | lib QtCore : qtmain | |
374 | : # requirements | |
375 | <name>Qt$(.infix_version)Core | |
376 | $(target-requirements) | |
377 | : # default-build | |
378 | : # usage-requirements | |
379 | <define>QT_CORE_LIB | |
380 | <define>QT_NO_DEBUG | |
381 | <include>$(.incprefix)/QtCore | |
382 | $(usage-requirements) | |
383 | ; | |
384 | ||
385 | if $(.have_separate_debug) = TRUE | |
386 | { | |
387 | debug-message Configure debug libraries with suffix '$(.suffix_debug)' ; | |
388 | ||
389 | lib QtCore : $(main) | |
390 | : # requirements | |
391 | <name>Qt$(.infix_version)Core$(.suffix_debug) | |
392 | <variant>debug | |
393 | $(target-requirements) | |
394 | : # default-build | |
395 | : # usage-requirements | |
396 | <define>QT_CORE_LIB | |
397 | <include>$(.incprefix)/QtCore | |
398 | $(usage-requirements) | |
399 | ; | |
400 | } | |
401 | } | |
402 | ||
403 | if [ glob $(.incprefix)/QtAngle ] | |
404 | { | |
405 | # Setup support of ANGLE builds. | |
406 | alias QtAngle | |
407 | : # sources | |
408 | : # requirements | |
409 | $(target-requirements) | |
410 | : # default-build | |
411 | : # usage-requirements | |
412 | <define>QT_OPENGL_ES_2 | |
413 | <define>QT_OPENGL_ES_2_ANGLE | |
414 | <include>$(.incprefix)/QtAngle | |
415 | $(usage-requirements) | |
416 | ; | |
417 | } | |
418 | else | |
419 | { | |
420 | alias QtAngle | |
421 | : # sources | |
422 | : # requirements | |
423 | $(target-requirements) | |
424 | ; | |
425 | } | |
426 | ||
427 | # Initialising the remaining libraries is canonical | |
428 | # parameters 'module' : 'depends-on' : 'usage-define' : 'requirements' : 'include' | |
429 | # 'include' only for non-canonical include paths. | |
430 | add-shared-library QtGui : QtCore QtAngle : QT_GUI_LIB : $(target-requirements) ; | |
431 | add-shared-library QtWidgets : QtGui : QT_WIDGETS_LIB : $(target-requirements) ; | |
432 | add-shared-library QtNetwork : QtCore : QT_NETWORK_LIB : $(target-requirements) ; | |
433 | add-shared-library QtSql : QtCore : QT_SQL_LIB : $(target-requirements) ; | |
434 | add-shared-library QtXml : QtCore : QT_XML_LIB : $(target-requirements) ; | |
435 | add-shared-library QtPrintSupport : QtGui : QT_PRINTSUPPORT_LIB : $(target-requirements) ; | |
436 | add-shared-library QtConcurrent : QtCore : QT_CONCURRENT_LIB : $(target-requirements) ; | |
437 | ||
438 | add-shared-library QtPositioning : QtCore : QT_POSITIONING_LIB : $(target-requirements) ; | |
439 | ||
440 | add-shared-library QtOpenGL : QtGui : QT_OPENGL_LIB : $(target-requirements) ; | |
441 | add-shared-library QtSvg : QtXml QtOpenGL : QT_SVG_LIB : $(target-requirements) ; | |
442 | ||
443 | add-shared-library QtTest : QtCore : : $(target-requirements) ; | |
444 | ||
445 | # Qt designer library et. al. | |
446 | add-shared-library QtDesigner : QtGui QtXml : : $(target-requirements) ; | |
447 | add-shared-library QtDesignerComponents : QtGui QtXml : : $(target-requirements) ; | |
448 | add-static-library QtUiTools : QtGui QtXml : $(target-requirements) ; | |
449 | ||
450 | # DBus-Support | |
451 | add-shared-library QtDBus : QtXml : : $(target-requirements) ; | |
452 | ||
453 | # Script-Engine and Tools | |
454 | add-shared-library QtScript : QtGui QtXml : QT_SCRIPT_LIB : $(target-requirements) ; | |
455 | add-shared-library QtScriptTools : QtScript : QT_SCRIPTTOOLS_LIB : $(target-requirements) ; | |
456 | ||
457 | # WebKit | |
458 | add-shared-library QtWebKit : QtGui : QT_WEBKIT_LIB : $(target-requirements) ; | |
459 | add-shared-library QtWebKitWidgets : QtGui : QT_WEBKITWIDGETS_LIB : $(target-requirements) ; | |
460 | ||
461 | # Multimedia engine | |
462 | add-shared-library QtMultimedia : QtGui : QT_MULTIMEDIA_LIB : $(target-requirements) ; | |
463 | add-shared-library QtMultimediaWidgets : QtMultimedia : QT_MULTIMEDIAWIDGETS_LIB : $(target-requirements) ; | |
464 | ||
465 | # | |
466 | add-shared-library QtXmlPatterns : QtNetwork : QT_XMLPATTERNS_LIB : $(target-requirements) ; | |
467 | ||
468 | # Help-Engine | |
469 | add-shared-library QtHelp : QtGui QtSql QtXml : : $(target-requirements) ; | |
470 | add-shared-library QtCLucene : QCore QtSql QtXml : : $(target-requirements) ; | |
471 | ||
472 | # QtQuick | |
473 | add-shared-library QtQml : QtCore QtNetwork QtGui : QT_QML_LIB : $(target-requirements) ; | |
474 | add-shared-library QtQuick : QtQml : QT_QUICK_LIB : $(target-requirements) ; | |
475 | add-shared-library QtQuickParticles : QtQml : : $(target-requirements) ; | |
476 | add-shared-library QtQuickTest : QtQml : : $(target-requirements) ; | |
477 | ||
478 | add-shared-library QtSerialPort : QtCore : QT_SERIALPORT_LIB : $(target-requirements) ; | |
479 | ||
480 | # QtLocation (since 5.4) | |
481 | add-shared-library QtLocation : QtQuick QtPositioning : QT_LOCATION_LIB : $(target-requirements) ; | |
482 | ||
483 | # Webengine support (since 5.4) | |
484 | add-shared-library QtWebEngine : QtGui : QT_WEBENGINE_LIB : $(target-requirements) ; | |
485 | add-shared-library QtWebEngineCore : QtWebEngine : QT_WEBENGINECORE_LIB : $(target-requirements) ; | |
486 | add-shared-library QtWebEngineWidgets : QtWebEngineCore QtWidgets : QT_WEBENGINEWIDGETS_LIB : $(target-requirements) ; | |
487 | ||
488 | add-shared-library QtWebChannel : QtQml : QT_WEBCHANNEL_LIB : $(target-requirements) ; | |
489 | add-shared-library QtWebSockets : QtNetwork : QT_WEBSOCKETS_LIB : $(target-requirements) ; | |
490 | ||
491 | add-shared-library QtWebView : QtWebEngineCore QtWebChannel : QT_WEBVIEW_LIB : $(target-requirements) ; | |
492 | ||
493 | # Qt3d libraries (since 5.6) | |
494 | add-shared-library Qt3DCore : QtGui : QT_3DCORE_LIB : $(target-requirements) ; | |
495 | add-shared-library Qt3DRender : Qt3DCore QtConcurrent : QT_3DRENDER_LIB : $(target-requirements) ; | |
496 | add-shared-library Qt3DLogic : Qt3DCore : QT_3DLOGIC_LIB : $(target-requirements) ; | |
497 | add-shared-library Qt3DInput : Qt3DRender : QT_3DINPUT_LIB : $(target-requirements) ; | |
498 | ||
499 | # QtCharts (since 5.7) | |
500 | add-shared-library QtCharts : QtWidgets : QT_CHARTS_LIB : $(target-requirements) ; | |
501 | ||
502 | # 3D data visualization (since 5.7) | |
503 | add-shared-library QtDataVisualization : QtGui : QT_DATAVISUALIZATION_LIB : $(target-requirements) ; | |
504 | ||
505 | # In-App purchase API (since 5.7) | |
506 | add-shared-library QtPurchasing : QtCore : QT_PURCHASING_LIB : $(target-requirements) ; | |
507 | ||
508 | # Qt Connectivity (since 5.3) | |
509 | add-shared-library QtBluetooth : QtCore : QT_BLUETOOTH_LIB : $(target-requirements) ; | |
510 | add-shared-library QtNfc : QtCore : QT_NFC_LIB : $(target-requirements) ; | |
511 | ||
512 | # Gamepad (since 5.7) | |
513 | add-shared-library QtGamepad : QtCore : QT_GAMEPAD_LIB : $(target-requirements) ; | |
514 | ||
515 | # SCXML state machine (since 5.7) | |
516 | add-shared-library QtScxml : QtCore : QT_SCXML_LIB : $(target-requirements) ; | |
517 | ||
518 | # Tech Preview QtQuick | |
519 | # SerialBus (since 5.7) | |
520 | add-shared-library QtSerialBus : QtCore : QT_SERIALBUS_LIB : $(target-requirements) ; | |
521 | ||
522 | # Platform dependent libraries | |
523 | # Regular expression support | |
524 | add-shared-library QtV8 : QtCore : : $(target-requirements) ; | |
525 | ||
526 | # QML-Engine version1 | |
527 | add-shared-library QtDeclarative : QtXml : : $(target-requirements) ; | |
528 | ||
529 | debug-message "==== Configured Qt-$(version) ====" ; | |
530 | ||
531 | project.pop-current ; | |
532 | } | |
533 | ||
534 | rule initialized ( ) | |
535 | { | |
536 | return $(.initialized) ; | |
537 | } | |
538 | ||
539 | ||
540 | ||
541 | # This custom generator is needed because in QT5, UI files are translated only | |
542 | # into H files, and no C++ files are created. Further, the H files need not be | |
543 | # passed via MOC. The header is used only via inclusion. If we define a standard | |
544 | # UI -> H generator, Boost.Build will run MOC on H, and then compile the | |
545 | # resulting cpp. It will give a warning, since output from moc will be empty. | |
546 | # | |
547 | # This generator is declared with a UI -> OBJ signature, so it gets invoked when | |
548 | # linking generator tries to convert sources to OBJ, but it produces target of | |
549 | # type H. This is non-standard, but allowed. That header won't be mocced. | |
550 | # | |
551 | class uic-5-generator : generator | |
552 | { | |
553 | rule __init__ ( * : * ) | |
554 | { | |
555 | generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; | |
556 | } | |
557 | ||
558 | rule run ( project name ? : property-set : sources * ) | |
559 | { | |
560 | if ! $(name) | |
561 | { | |
562 | name = [ $(sources[0]).name ] ; | |
563 | name = $(name:B) ; | |
564 | } | |
565 | ||
566 | local a = [ new action $(sources[1]) : qt5.uic : $(property-set) ] ; | |
567 | ||
568 | # The 'ui_' prefix is to match qmake's default behavior. | |
569 | local target = [ new file-target ui_$(name) : H : $(project) : $(a) ] ; | |
570 | ||
571 | local r = [ virtual-target.register $(target) ] ; | |
572 | ||
573 | # Since this generator will return a H target, the linking generator | |
574 | # won't use it at all, and won't set any dependency on it. However, we | |
575 | # need the target to be seen by bjam, so that dependency from sources to | |
576 | # this generated header is detected -- if jam does not know about this | |
577 | # target, it won't do anything. | |
578 | DEPENDS all : [ $(r).actualize ] ; | |
579 | ||
580 | return $(r) ; | |
581 | } | |
582 | } | |
583 | ||
584 | ||
585 | class moc-h-5-generator : generator | |
586 | { | |
587 | rule __init__ ( * : * ) | |
588 | { | |
589 | generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; | |
590 | } | |
591 | ||
592 | rule run ( project name ? : property-set : sources * ) | |
593 | { | |
594 | if ! $(sources[2]) && [ $(sources[1]).type ] = MOCCABLE5_CPP | |
595 | { | |
596 | name = [ $(sources[0]).name ] ; | |
597 | name = $(name:B) ; | |
598 | ||
599 | local a = [ new action $(sources[1]) : qt5.moc.inc : | |
600 | $(property-set) ] ; | |
601 | ||
602 | local target = [ new file-target $(name) : MOC : $(project) : $(a) | |
603 | ] ; | |
604 | ||
605 | local r = [ virtual-target.register $(target) ] ; | |
606 | ||
607 | # Since this generator will return a H target, the linking generator | |
608 | # won't use it at all, and won't set any dependency on it. However, | |
609 | # we need the target to be seen by bjam, so that dependency from | |
610 | # sources to this generated header is detected -- if jam does not | |
611 | # know about this target, it won't do anything. | |
612 | DEPENDS all : [ $(r).actualize ] ; | |
613 | ||
614 | return $(r) ; | |
615 | } | |
616 | } | |
617 | } | |
618 | ||
619 | ||
620 | class moc-inc-5-generator : generator | |
621 | { | |
622 | rule __init__ ( * : * ) | |
623 | { | |
624 | generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; | |
625 | } | |
626 | ||
627 | rule run ( project name ? : property-set : sources * ) | |
628 | { | |
629 | if ! $(sources[2]) && [ $(sources[1]).type ] = MOCCABLE5_H | |
630 | { | |
631 | name = [ $(sources[0]).name ] ; | |
632 | name = $(name:B) ; | |
633 | ||
634 | local a = [ new action $(sources[1]) : qt5.moc.inc : | |
635 | $(property-set) ] ; | |
636 | ||
637 | local target = [ new file-target moc_$(name) : CPP : $(project) : | |
638 | $(a) ] ; | |
639 | ||
640 | # Since this generator will return a H target, the linking generator | |
641 | # won't use it at all, and won't set any dependency on it. However, | |
642 | # we need the target to be seen by bjam, so that dependency from | |
643 | # sources to this generated header is detected -- if jam does not | |
644 | # know about this target, it won't do anything. | |
645 | DEPENDS all : [ $(target).actualize ] ; | |
646 | ||
647 | return [ virtual-target.register $(target) ] ; | |
648 | } | |
649 | } | |
650 | } | |
651 | ||
652 | ||
653 | # Query the installation directory. This is needed in at least two scenarios. | |
654 | # First, when re-using sources from the Qt-Tree. Second, to "install" custom Qt | |
655 | # plugins to the Qt-Tree. | |
656 | # | |
657 | rule directory | |
658 | { | |
659 | return $(.PREFIX) ; | |
660 | } | |
661 | ||
662 | # Add a shared Qt library. | |
663 | rule add-shared-library ( lib-name : depends-on * : usage-defines * : requirements * : include ? ) | |
664 | { | |
665 | add-library $(lib-name) : $(.infix_version) : $(depends-on) : $(usage-defines) : $(requirements) : $(include) ; | |
666 | } | |
667 | ||
668 | # Add a static Qt library. | |
669 | rule add-static-library ( lib-name : depends-on * : usage-defines * : requirements * : include ? ) | |
670 | { | |
671 | add-library $(lib-name) : $(.infix_version) : $(depends-on) : $(usage-defines) : $(requirements) : $(include) ; | |
672 | } | |
673 | ||
674 | # Add a Qt library. | |
675 | # Static libs are unversioned, whereas shared libs have the major number as suffix. | |
676 | # Creates both release and debug versions on platforms where both are enabled by Qt configure. | |
677 | # Flags: | |
678 | # - lib-name Qt library Name | |
679 | # - version Qt major number used as shared library suffix (QtCore5.so) | |
680 | # - depends-on other Qt libraries | |
681 | # - usage-defines those are set by qmake, so set them when using this library | |
92f5a8d4 | 682 | # - requirements additional requirements |
7c673cae FG |
683 | # - include non-canonical include path. The canonical path is $(.incprefix)/$(lib-name). |
684 | rule add-library ( lib-name : version ? : depends-on * : usage-defines * : requirements * : include ? ) | |
685 | { | |
686 | if $(.bjam-qt) | |
687 | { | |
688 | # Import Qt module | |
689 | # Eveything will be setup there | |
690 | alias $(lib-name) | |
691 | : $(.prefix)//$(lib-name) | |
692 | : | |
693 | : | |
694 | : <allow>qt5 ; | |
695 | } | |
696 | else | |
697 | { | |
698 | local real_include ; | |
699 | real_include ?= $(include) ; | |
700 | real_include ?= $(lib-name) ; | |
701 | ||
702 | local real_name = [ MATCH ^Qt(.*) : $(lib-name) ] ; | |
703 | ||
704 | lib $(lib-name) | |
705 | : # sources | |
706 | $(depends-on) | |
707 | : # requirements | |
708 | <name>Qt$(version)$(real_name) | |
709 | $(requirements) | |
710 | : # default-build | |
711 | : # usage-requirements | |
712 | <define>$(usage-defines) | |
713 | <include>$(.incprefix)/$(real_include) | |
714 | ; | |
715 | ||
716 | if $(.have_separate_debug) = TRUE | |
717 | { | |
718 | lib $(lib-name) | |
719 | : # sources | |
720 | $(depends-on) | |
721 | : # requirements | |
722 | <name>Qt$(version)$(real_name)$(.suffix_debug) | |
723 | $(requirements) | |
724 | <variant>debug | |
725 | : # default-build | |
726 | : # usage-requirements | |
727 | <define>$(usage-defines) | |
728 | <include>$(.incprefix)/$(real_include) | |
729 | ; | |
730 | } | |
731 | } | |
732 | ||
733 | # Make library explicit so that a simple <use>qt5 will not bring in everything. | |
734 | # And some components like QtDBus/Phonon may not be available on all platforms. | |
735 | explicit $(lib-name) ; | |
736 | } | |
737 | ||
738 | # Use $(.BINPREFIX[-1]) for the paths as several tools-requirements can match. | |
739 | # The exact match is the last one. | |
740 | ||
741 | # Get <include> and <defines> from current toolset. | |
742 | flags qt5.moc INCLUDES <include> ; | |
743 | flags qt5.moc DEFINES <define> ; | |
744 | ||
745 | # need a newline for expansion of DEFINES and INCLUDES in the response file. | |
746 | .nl = " | |
747 | " ; | |
748 | ||
749 | # Processes headers to create Qt MetaObject information. Qt5-moc has its | |
750 | # c++-parser, so pass INCLUDES and DEFINES. | |
751 | # We use response file with one INCLUDE/DEFINE per line | |
752 | # | |
753 | actions moc | |
754 | { | |
755 | $(.BINPREFIX[-1])/moc $(>) -o $(<) @"@($(<).rsp:E=-D$(DEFINES)$(.nl) -I$(INCLUDES:T)$(.nl))" | |
756 | } | |
757 | ||
758 | # When moccing files for include only, we don't need -f, otherwise the generated | |
759 | # code will include the .cpp and we'll get duplicated symbols. | |
760 | # | |
761 | actions moc.inc | |
762 | { | |
763 | $(.BINPREFIX[-1])/moc $(>) -o $(<) @"@($(<).rsp:E=-D$(DEFINES)$(.nl) -I$(INCLUDES:T)$(.nl))" | |
764 | } | |
765 | ||
766 | ||
767 | # Get extra options for RCC | |
768 | flags qt5.rcc RCC_OPTIONS <rccflags> ; | |
769 | ||
770 | # Generates source files from resource files. | |
771 | # | |
772 | actions rcc | |
773 | { | |
774 | $(.BINPREFIX[-1])/rcc $(>) -name $(>:B) $(RCC_OPTIONS) -o $(<) | |
775 | } | |
776 | ||
777 | ||
778 | # Generates user-interface source from .ui files. | |
779 | # | |
780 | actions uic | |
781 | { | |
782 | $(.BINPREFIX[-1])/uic $(>) -o $(<) | |
783 | } | |
784 | ||
785 | ||
786 | # Scanner for .qrc files. Look for the CDATA section of the <file> tag. Ignore | |
787 | # the "alias" attribute. See http://doc.trolltech.com/qt/resources.html for | |
788 | # detailed documentation of the Qt Resource System. | |
789 | # | |
790 | class qrc-5-scanner : common-scanner | |
791 | { | |
792 | rule pattern ( ) | |
793 | { | |
794 | return "<file.*>(.*)</file>" ; | |
795 | } | |
796 | } | |
797 | ||
798 | ||
799 | # Wrapped files are "included". | |
800 | scanner.register qrc-5-scanner : include ; |