1
/****************************************************************************
3
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4
** All rights reserved.
5
** Contact: Nokia Corporation (qt-info@nokia.com)
7
** This file is part of the documentation of the Qt Toolkit.
9
** $QT_BEGIN_LICENSE:LGPL$
10
** No Commercial Usage
11
** This file contains pre-release code and may not be distributed.
12
** You may use this file in accordance with the terms and conditions
13
** contained in the Technology Preview License Agreement accompanying
16
** GNU Lesser General Public License Usage
17
** Alternatively, this file may be used under the terms of the GNU Lesser
18
** General Public License version 2.1 as published by the Free Software
19
** Foundation and appearing in the file LICENSE.LGPL included in the
20
** packaging of this file. Please review the following information to
21
** ensure the GNU Lesser General Public License version 2.1 requirements
22
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24
** In addition, as a special exception, Nokia gives you certain additional
25
** rights. These rights are described in the Nokia Qt LGPL Exception
26
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28
** If you have questions regarding the use of this file, please contact
29
** Nokia at qt-info@nokia.com.
40
****************************************************************************/
43
\page qmake-manual.html
45
\startpage {index.html}{Qt Reference Documentation}
46
\nextpage qmake Tutorial
51
\c qmake is a tool that helps simplify the build
52
process for development project across different platforms. \c qmake
53
automates the generation of Makefiles so that only a few lines of
54
information are needed to create each Makefile. \c qmake can be used for
55
any software project, whether it is written in Qt or not.
57
\c qmake generates a Makefile based on the information in a project
58
file. Project files are created by the developer, and are usually
59
simple, but more sophisticated project files can be created for
61
\c qmake contains additional features to support development with Qt,
62
automatically including build rules for \l{moc.html}{moc}
63
and \l{uic.html}{uic}.
64
\c qmake can also generate projects for Microsoft Visual studio
65
without requiring the developer to change the project file.
67
\section1 Getting Started
69
The \l{qmake Tutorial} and guide to \l{qmake Common Projects} provide overviews
70
that aim to help new users get started with \c qmake.
74
\tableofcontents{1 qmake Tutorial}
78
\o \l{qmake Common Projects}
79
\tableofcontents{1 qmake Common Projects}
82
\section1 Table of Contents
86
\tableofcontents{1 Using qmake}
87
\o \l{qmake Project Files}
88
\tableofcontents{1 qmake Project Files}
90
\tableofcontents{1 Running qmake}
91
\o \l{qmake Platform Notes}
92
\tableofcontents{1 qmake Platform Notes}
93
\o \l{qmake Advanced Usage}
94
\tableofcontents{1 qmake Advanced Usage}
95
\o \l{Using Precompiled Headers}
96
\tableofcontents{1 Using Precompiled Headers}
97
\o \l{qmake Reference}
98
\tableofcontents{1 qmake Reference}
99
\o \l{qmake Variable Reference}
100
\tableofcontents{1 qmake Variable Reference}
101
\o \l{qmake Function Reference}
102
\tableofcontents{1 qmake Function Reference}
103
\o \l{Configuring qmake's Environment}
104
\tableofcontents{1 Configuring qmake's Environment}
109
\page qmake-using.html
111
\contentspage {qmake Manual}{Contents}
112
\previouspage qmake Manual
113
\nextpage qmake Project Files
115
\c qmake provides a project-oriented system for managing the build
116
process for applications, libraries, and other components. This
117
approach gives developers control over the source files used, and
118
allows each of the steps in the process to be described concisely,
119
typically within a single file. \c qmake expands the information in
120
each project file to a Makefile that executes the necessary commands
121
for compiling and linking.
123
In this document, we provide a basic introduction to project files,
124
describe some of the main features of \c qmake, and show how to use
125
\c qmake on the command line.
127
\section1 Describing a Project
129
Projects are described by the contents of project (\c .pro) files.
130
The information within these is used by \c qmake to generate a Makefile
131
containing all the commands that are needed to build each project.
132
Project files typically contain a list of source and header files,
133
general configuration information, and any application-specific details,
134
such as a list of extra libraries to link against, or a list of extra
135
include paths to use.
137
Project files can contain a number of different elements, including
138
comments, variable declarations, built-in functions, and some simple
139
control structures. In most simple projects, it is only necessary
140
to declare the source and header files that are used to build the
141
project with some basic configuration options.
143
Complete examples of project files can be found in the
145
An introduction to project files can be found in the
146
\l{qmake Project Files} chapter, and a more detailed description is
147
available in the \l{qmake Reference}.
149
\section1 Building a Project
151
For simple projects, you only need to run \c qmake in the top
152
level directory of your project. By default, \c qmake generates a
153
Makefile that you then use to build the project, and you can then
154
run your platform's \c make tool to build the project.
156
\c qmake can also be used to generate project files. A full
157
description of \c{qmake}'s command line options can be found in the
158
\l{Running qmake} chapter of this manual.
160
\section1 Using Precompiled Headers
162
In large projects, it is possible to take advantage of precompiled
163
header files to speed up the build process. This feature is described
164
in detail in the \l{Using Precompiled Headers} chapter.
168
\page qmake-project-files.html
169
\title qmake Project Files
170
\contentspage {qmake Manual}{Contents}
171
\previouspage Using qmake
172
\nextpage Running qmake
174
Project files contain all the information required by \c qmake to build
175
your application, library, or plugin. The resources used by your project
176
are generally specified using a series of declarations, but support for
177
simple programming constructs allow you to describe different build
178
processes for different platforms and environments.
182
\section1 Project File Elements
184
The project file format used by \c qmake can be used to support both
185
simple and fairly complex build systems. Simple project files will
186
use a straightforward declarative style, defining standard variables
187
to indicate the source and header files that are used in the project.
188
Complex projects may use the control flow structures to fine-tune the
191
The following sections describe the different types of elements used
196
In a project file, variables are used to hold lists of strings.
197
In the simplest projects, these variables inform \c qmake about the
198
configuration options to use, or supply filenames and paths to use
199
in the build process.
201
\c qmake looks for certain variables in each project file, and it
202
uses the contents of these to determine what it should write to a
203
Makefile. For example, the list of values in the \c HEADERS and
204
\c SOURCES variables are used to tell \c qmake about header and
205
source files in the same directory as the project file.
207
Variables can also be used internally to store temporary lists of values,
208
and existing lists of values can be overwritten or extended with new
211
The following lines show how lists of values are assigned to variables:
213
\snippet doc/src/snippets/qmake/variables.pro 0
215
Note that the first assignment only includes values that are specified on
216
the same line as the \c SOURCES variable. The second assignment splits
217
the items across lines by using the \c \\ character.
219
The list of values in a variable is extended in the following way:
221
\snippet doc/src/snippets/qmake/variables.pro 1
223
The \c CONFIG variable is another special variable that \c qmake
224
uses when generating a Makefile. It is discussed in the section on
225
\l{#GeneralConfiguration}{general configuration} later in this chapter.
226
In the above line, \c qt is added to the list of existing values
227
contained in \c CONFIG.
229
The following table lists the variables that \c qmake recognizes, and
230
describes what they should contain.
233
\header \o Variable \o Contents
234
\row \o CONFIG \o General project configuration options.
235
\row \o DESTDIR \o The directory in which the executable or binary file will
237
\row \o FORMS \o A list of UI files to be processed by \c uic.
238
\row \o HEADERS \o A list of filenames of header (.h) files used when
239
building the project.
240
\row \o QT \o Qt-specific configuration options.
241
\row \o RESOURCES \o A list of resource (.rc) files to be included in the
242
final project. See the \l{The Qt Resource System} for
243
more information about these files.
244
\row \o SOURCES \o A list of source code files to be used when building
246
\row \o TEMPLATE \o The template to use for the project. This determines
247
whether the output of the build process will be an
248
application, a library, or a plugin.
251
The contents of a variable can be read by prepending the variable name with
252
\c $$. This can be used to assign the contents of one variable to another:
254
\snippet doc/src/snippets/qmake/dereferencing.pro 0
256
The \c $$ operator is used extensively with built-in functions that operate
257
on strings and lists of values. These are described in the chapter on
258
\l{qmake Advanced Usage}.
262
Normally, variables are used to contain whitespace-separated lists
263
of values. However, it is sometimes necessary to specify values containing
264
spaces. These must be quoted by using the
265
\l{qmake Function Reference#quote-string}{quote()} function in the following way:
267
\snippet doc/src/snippets/qmake/quoting.pro 0
269
The quoted text is treated as a single item in the list of values held by
270
the variable. A similar approach is used to deal with paths that contain
271
spaces, particularly when defining the
272
\l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH} and
273
\l{qmake Variable Reference#LIBS}{LIBS} variables for the Windows platform.
274
In cases like these, the \l{qmake Function Reference#quote(string)}{quote()}
275
function can be used in the following way:
277
\snippet doc/src/snippets/qmake/spaces.pro quoting include paths with spaces
281
You can add comments to project files. Comments begin with the \c
282
# character and continue to the end of the same line. For example:
284
\snippet doc/src/snippets/qmake/comments.pro 0
286
To include the \c # character in variable assignments, it is necessary
287
to use the contents of the built-in \c LITERAL_HASH variable. See the
288
\l{qmake Variable Reference#LITERAL_HASH}{variable reference} for more
291
\section2 Built-in Functions and Control Flow
293
\c qmake provides a number of built-in functions to allow the contents
294
of variables to be processed. The most commonly used function in simple
295
project files is the \c include function which takes a filename as an
296
argument. The contents of the given file are included in the project
297
file at the place where the \c include function is used.
298
The \c include function is most commonly used to include other project
301
\snippet doc/src/snippets/qmake/include.pro 0
303
Support for conditional structures is made available via
304
\l{qmake Advanced Usage#scopes}{scopes} that behave like \c if
305
statements in programming languages:
307
\snippet doc/src/snippets/qmake/scopes.pro 0
309
The assignments inside the braces are only made if the condition is
310
true. In this case, the special \c win32 variable must be set; this
311
happens automatically on Windows, but this can also be specified on
312
other platforms by running \c qmake with the \c{-win32} command line
313
option (see \l{Running qmake} for more information). The opening
314
brace must stand on the same line as the condition.
316
Simple loops are constructed by iterating over lists of values using
317
the built-in \c for function. The following code adds directories
318
to the \l{qmake Variable Reference#SUBDIRS}{SUBDIRS} variable, but
321
\snippet doc/src/snippets/qmake/functions.pro 0
323
More complex operations on variables that would usually require loops
324
are provided by built-in functions such as \c find, \c unique, and
325
\c count. These functions, and many others are provided to manipulate
326
strings and paths, support user input, and call external tools. A list
327
of the functions available can be found in the
328
\l{qmake Advanced Usage} chapter of this manual.
330
\section1 Project Templates
332
The \c TEMPLATE variable is used to define the type of project that will
333
be built. If this is not declared in the project file, \c qmake assumes
334
that an application should be built, and will generate an appropriate
335
Makefile (or equivalent file) for the purpose.
337
The types of project available are listed in the following table with
338
information about the files that \c qmake will generate for each of them:
341
\header \o Template \o Description of \c qmake output
342
\row \o app (default) \o Creates a Makefile to build an application.
343
\row \o lib \o Creates a Makefile to build a library.
344
\row \o subdirs \o Creates a Makefile containing rules for the
345
subdirectories specified using the \l{qmake Variable Reference#SUBDIRS}{SUBDIRS}
346
variable. Each subdirectory must contain its own project file.
347
\row \o vcapp \o Creates a Visual Studio Project file to build
349
\row \o vclib \o Creates a Visual Studio Project file to build a library.
352
See the \l{qmake Tutorial} for advice on writing project files for
353
projects that use the \c app and \c lib templates.
355
When the \c subdirs template is used, \c qmake generates a Makefile
356
to examine each specified subdirectory, process any project file it finds
357
there, and run the platform's \c make tool on the newly-created Makefile.
358
The \l{qmake Variable Reference#SUBDIRS}{SUBDIRS} variable is used to
359
contain a list of all the subdirectories to be processed.
361
\target GeneralConfiguration
362
\section1 General Configuration
364
The \l{qmake Variable Reference#CONFIG}{CONFIG variable} specifies the
365
options and features that the compiler should use and the libraries that
366
should be linked against. Anything can be added to the \c CONFIG variable,
367
but the options covered below are recognized by \c qmake internally.
369
The following options control the compiler flags that are used to build the
373
\header \o Option \o Description
374
\row \o release \o The project is to be built in release mode.
375
This is ignored if \c debug is also specified.
376
\row \o debug \o The project is to be built in debug mode.
377
\row \o debug_and_release \o The project is built in \e both debug and
379
\row \o debug_and_release_target \o The project is built in \e both debug
380
and release modes. TARGET is built into \e both the debug and release directories.
381
\row \o build_all \o If \c debug_and_release is specified, the project is
382
built in both debug and release modes by default.
383
\row \o autogen_precompile_source \o Automatically generates a \c .cpp file that includes
384
the precompiled header file specified in the .pro file.
385
\row \o ordered \o When using the \c subdirs template, this option
386
specifies that the directories listed should be processed in the
387
order in which they are given.
388
\row \o warn_on \o The compiler should output as many warnings as possible.
389
This is ignored if \c warn_off is specified.
390
\row \o warn_off \o The compiler should output as few warnings as possible.
391
\row \o copy_dir_files \o Enables the install rule to also copy directories, not just files.
394
The \c debug_and_release option is special in that it enables \e both debug and
395
release versions of a project to be built. In such a case, the Makefile that
396
\c qmake generates includes a rule that builds both versions, and this can be
397
invoked in the following way:
399
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 0
401
Adding the \c build_all option to the \c CONFIG variable makes this rule
402
the default when building the project, and installation targets will be
403
created for both debug and release builds.
405
Note that each of the options specified in the \c CONFIG variable can also be
406
used as a scope condition.
407
You can test for the presence of certain configuration options by using the
408
built-in \l{qmake Function Reference#CONFIG(config)}{CONFIG()} function.
409
For example, the following lines show the function as the condition in a scope
410
to test whether only the \c opengl option is in use:
412
\snippet doc/src/snippets/qmake/configscopes.pro 4
413
\snippet doc/src/snippets/qmake/configscopes.pro 5
415
This enables different configurations to be defined for \c release and
416
\c debug builds, and is described in more detail in the
417
\l{qmake Advanced Usage#Scopes}{Scopes} section of the
418
\l{qmake Advanced Usage}{Advanced Usage} chapter of this manual.
420
The following options define the type of project to be built. Note that some
421
of these options only take effect when used on the relevant platform. On other
422
platforms, they have no effect.
425
\header \o Option \o Description
426
\row \o qt \o The project is a Qt application and should link against the Qt
427
library. You can use the \c QT variable to control any additional
428
Qt modules that are required by your application.
429
\row \o thread \o The project is a multi-threaded application.
430
\row \o x11 \o The project is an X11 application or library.
433
When using \l{qmake Variable Reference#TEMPLATE}{application or library project
434
templates}, more specialized configuration options can be used to fine tune the
435
build process. These are explained in details in the
436
\l{qmake-common-projects.html}{Common Projects} chapter of this manual.
438
For example, if your application uses the Qt library and you want to
439
build it as a multi-threaded application in \c debug mode, your project
440
file will contain the following line:
442
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 1
444
Note, that you must use "+=", not "=", or \c qmake will not be able to
445
use Qt's configuration to determine the settings needed for your project.
447
\section1 Declaring Qt Libraries
449
If the \c CONFIG variable contains the \c qt value, qmake's support for Qt
450
applications is enabled. This makes it possible to fine-tune which of the
451
Qt modules are used by your application. This is achieved with the \c QT
452
variable which can be used to declare the required extension modules.
453
For example, we can enable the XML and network modules in the following way:
455
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 2
457
Note that \c QT includes the \c core and \c gui modules by default, so the
458
above declaration \e adds the network and XML modules to this default list.
459
The following assignment \e omits the default modules, and will lead to
460
errors when the application's source code is being compiled:
462
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 3
464
If you want to build a project \e without the \c gui module, you need to
465
exclude it with the "-=" operator. By default, \c QT contains both
466
\c core and \c gui, so the following line will result in a minimal
467
Qt project being built:
469
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 4
471
The table below shows the options that can be used with the \c QT variable
472
and the features that are associated with each of them:
475
\header \o Option \o Features
476
\row \o core (included by default) \o QtCore module
477
\row \o gui (included by default) \o QtGui module
478
\row \o network \o QtNetwork module
479
\row \o opengl \o QtOpenGL module
480
\row \o sql \o QtSql module
481
\row \o svg \o QtSvg module
482
\row \o xml \o QtXml module
483
\row \o xmlpatterns \o QtXmlPatterns module
484
\row \o qt3support \o Qt3Support module
487
Note that adding the \c opengl option to the \c QT variable automatically
488
causes the equivalent option to be added to the \c CONFIG variable.
489
Therefore, for Qt applications, it is not necessary to add the \c opengl
490
option to both \c CONFIG and \c{QT}.
492
\section1 Configuration Features
494
\c qmake can be set up with extra configuration features that are specified
495
in feature (.prf) files. These extra features often provide support for
496
custom tools that are used during the build process. To add a feature to
497
the build process, append the feature name (the stem of the feature filename)
498
to the \c CONFIG variable.
500
For example, \c qmake can configure the build process to take advantage
501
of external libraries that are supported by
502
\l{http://www.freedesktop.org/wiki/Software_2fpkgconfig}{pkg-config},
503
such as the D-Bus and ogg libraries, with the following lines:
505
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 5
507
More information about features can be found in the
508
\l{qmake Advanced Usage#Adding New Configuration Features}
509
{Adding New Configuration Features} section of the \l{qmake Advanced Usage}
512
\section1 Declaring Other Libraries
514
If you are using other libraries in your project in addition to those
515
supplied with Qt, you need to specify them in your project file.
517
The paths that \c qmake searches for libraries and the specific libraries
518
to link against can be added to the list of values in the
519
\l{qmake Variable Reference#LIBS}{LIBS} variable. The paths to the libraries
520
themselves can be given, or the familiar Unix-style notation for specifying
521
libraries and paths can be used if preferred.
523
For example, the following lines show how a library can be specified:
525
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 6
527
The paths containing header files can also be specified in a similar way
528
using the \l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH} variable.
530
For example, it is possible to add several paths to be searched for header
533
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 7
537
\page qmake-running.html
539
\contentspage {qmake Manual}{Contents}
540
\previouspage qmake Project Files
541
\nextpage qmake Platform Notes
543
The behavior of \c qmake can be customized when it is run by
544
specifying various options on the command line. These allow the
545
build process to be fine-tuned, provide useful diagnostic
546
information, and can be used to specify the target platform for
552
\section1 Command-Line Options
556
The syntax used to run \c qmake takes the following simple form:
558
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 8
560
\c qmake supports two different modes of operation: In the default mode,
561
\c qmake will use the description in a project file to generate a Makefile,
562
but it is also possible to use \c qmake to generate project files.
563
If you want to explicitly set the mode, you must specify it before all
564
other options. The \c mode can be either of the following two values:
568
\c qmake output will be a Makefile.
570
\c qmake output will be a project file. \BR
571
\bold{Note:} It is likely that the created file will need to be edited for example adding the \c QT variable to suit what modules are required for the project.
574
The following \c options are used to specify both general and mode-specific
575
settings. Options that only apply to the Makefile mode are described in the
576
\l{#MakefileMode}{Makefile Mode Options} section; options that influence the
577
creation of project files are described in the
578
\l{#ProjectMode}{Project File Options} section.
580
The \c files argument represents a list of one or more project files, separated
585
A wide range of options can be specified on the command line to \c qmake in
586
order to customize the build process, and to override default settings for
587
your platform. The following basic options provide usage information, specify
588
where \c qmake writes the output file, and control the level of debugging
589
information that will be written to the console:
593
\c qmake will go over these features and give some useful help.
595
\c qmake output will be directed to \e file. If this option
596
is not specified, \c qmake will try to use a suitable file name for its
597
output, depending on the mode it is running in.\BR
598
If '-' is specified, output is directed to stdout.
600
\c qmake will output debugging information.
603
For projects that need to be built differently on each target platform, with
604
many subdirectories, you can run \c qmake with each of the following
605
options to set the corresponding platform-specific variable in each
610
\c qmake will run in unix mode. In this mode, Unix file
611
naming and path conventions will be used, additionally testing for \c unix
612
(as a scope) will succeed. This is the default mode on all Unices.
614
\c qmake will run in Mac OS X mode. In this mode, Unix file
615
naming and path conventions will be used, additionally testing for \c macx
616
(as a scope) will succeed. This is the default mode on Mac OS X.
618
\c qmake will run in win32 mode. In this mode, Windows file naming and path
619
conventions will be used, additionally testing for \c win32 (as a scope)
620
will succeed. This is the default mode on Windows.
623
The template used for the project is usually specified by the \c TEMPLATE
624
variable in the project file. We can override or modify this by using the
629
\c qmake will override any set \c TEMPLATE variables with tmpl, but only
630
\e after the .pro file has been processed.
632
\c qmake will add the prefix to the \c TEMPLATE variable.
635
The level of warning information can be fine-tuned to help you find problems in
640
\c qmake will report all known warnings.
642
No warning information will be generated by \c qmake.
644
\c qmake will only generate parser warnings. This will alert
645
you to common pitfalls and potential problems in the parsing of your
648
\c qmake will warn of common pitfalls and potential problems in your
649
project file. For example, \c qmake will report whether a file is placed
650
into a list of files multiple times, or if a file cannot be found.
654
\section2 Makefile Mode Options
656
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 9
658
In Makefile mode, \c qmake will generate a Makefile that is used to build the
659
project. Additionally, the following options may be used in this mode to
660
influence the way the project file is generated:
664
\c qmake will process assignments given on the command line after
667
\c qmake will ignore the .qmake.cache file.
669
\c qmake will not generate any dependency information.
670
\o \c -cache file \BR
671
\c qmake will use \e file as the cache file, ignoring any other
672
.qmake.cache files found.
674
\c qmake will use \e spec as a path to platform and compiler information,
675
and the value of \c QMAKESPEC will be ignored.
678
You may also pass \c qmake assignments on the command line;
679
they will be processed before all of the files specified. For example:
681
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 10
683
This will generate a Makefile, from test.pro with Unix pathnames. However
684
many of the specified options aren't necessary as they are the default.
685
Therefore, the line can be simplified on Unix to:
687
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 11
689
If you are certain you want your variables processed after the
690
files specified, then you may pass the \c -after option. When this
691
is specified, all assignments on the command line after the \c -after
692
option will be postponed until after the specified files are parsed.
695
\section2 Project Mode Options
697
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 12
699
In project mode, \c qmake will generate a project file. Additionally, you
700
may supply the following options in this mode:
704
\c qmake will look through supplied directories recursively
706
\c qmake will not look in your current working directory for
707
source code and only use the specified \c files
710
In this mode, the \c files argument can be a list of files or directories.
711
If a directory is specified, it will be included in the \c DEPENDPATH
712
variable, and relevant code from there will be included in the generated
713
project file. If a file is given, it will be appended to the correct
714
variable, depending on its extension; for example, UI files are added
715
to \c FORMS, and C++ files are added to \c SOURCES.
717
You may also pass assignments on the command line in this mode. When doing
718
so, these assignments will be placed last in the generated project file.
722
\page qmake-platform-notes.html
723
\title qmake Platform Notes
724
\contentspage {qmake Manual}{Contents}
725
\previouspage Running qmake
726
\nextpage qmake Advanced Usage
728
Many cross-platform projects can be handled by the \c{qmake}'s basic
729
configuration features. On some platforms, it is sometimes useful, or even
730
necessary, to take advantage of platform-specific features. \c qmake knows
731
about many of these features, and these can be accessed via specific
732
variables that only have an effect on the platforms where they are relevant.
738
Features specific to this platform include support for creating universal
739
binaries, frameworks and bundles.
741
\section2 Source and Binary Packages
743
The version of \c qmake supplied in source packages is configured slightly
744
differently to that supplied in binary packages in that it uses a different
745
feature specification. Where the source package typically uses the
746
\c macx-g++ specification, the binary package is typically configured to
747
use the \c macx-xcode specification.
749
Users of each package can override this configuration by invoking \c qmake
750
with the \c -spec option (see \l{Running qmake} for more information). This
751
makes it possible, for example, to use \c qmake from a binary package to
752
create a Makefile in a project directory with the following command line
755
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 13
757
\section2 Using Frameworks
759
\c qmake is able to automatically generate build rules for linking against
760
frameworks in the standard framework directory on Mac OS X, located at
761
\c{/Library/Frameworks/}.
763
Directories other than the standard framework directory need to be specified
764
to the build system, and this is achieved by appending linker options to the
765
\l{qmake Variable Reference#QMAKE_LFLAGS}{QMAKE_LFLAGS} variable, as shown
766
in the following example:
768
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 14
770
The framework itself is linked in by appending the \c{-framework} options and
771
the name of the framework to the \l{qmake Variable Reference#LIBS}{LIBS}
774
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 15
776
\section2 Creating Frameworks
778
Any given library project can be configured so that the resulting library
780
\l{http://developer.apple.com/documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WhatAreFrameworks.html}
781
{framework}, ready for deployment. To do this, set up the project to use the
782
\l{qmake Variable Reference#TEMPLATE}{\c lib template} and add the
783
\c lib_bundle option to the
784
\l{qmake Variable Reference#CONFIG}{CONFIG} variable:
786
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 16
788
The data associated with the library is specified using the
789
\l{qmake Variable Reference#QMAKE_BUNDLE_DATA}{QMAKE_BUNDLE_DATA}
790
variable. This holds items that will be installed with a library
791
bundle, and is often used to specify a collection of header files,
792
as in the following example:
794
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 17
796
Here, the \c FRAMEWORK_HEADERS variable is a user-defined variable that
797
is used to define the headers required to use a particular framework.
798
Appending it to the \c QMAKE_BUNDLE_DATA variable ensures that the
799
information about these headers are added to the collection of
800
resources that will be installed with the library bundle. Also, the
801
framework's name and version are specified by
802
\l{qmake Variable Reference#QMAKE_FRAMEWORK_BUNDLE_NAME}
803
{QMAKE_FRAMEWORK_BUNDLE_NAME}
804
and \l{qmake Variable Reference#QMAKE_FRAMEWORK_VERSION}
805
{QMAKE_FRAMEWORK_VERSION} variables. By default, the values used for
806
these are obtained from the \l{qmake Variable Reference#TARGET}{TARGET}
807
and \l{qmake Variable Reference#VERSION}{VERSION} variables.
809
See \l{Deploying an Application on Mac OS X} for more information about
810
deploying applications and libraries.
812
\section2 Creating Universal Binaries
814
To create a universal binary for your application, you need to be using
815
a version of Qt that has been configured with the \c{-universal} option.
817
The architectures to be supported in the binary are specified with the
818
\l{qmake Variable Reference#CONFIG}{CONFIG} variable. For example, the
819
following assignment causes \c qmake to generate build rules to create
820
a universal binary for both PowerPC and x86 architectures:
822
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 18
824
Additionally, developers using a PowerPC-based platform need to set the
825
\l{qmake Variable Reference#QMAKE_MAC_SDK}{QMAKE_MAC_SDK} variable.
826
This process is discussed in more detail in the
827
\l{Deploying an Application on Mac OS X#Architecture Dependencies}{deployment guide for Mac OS X}.
829
\section2 Creating and Moving Xcode Projects
831
Developers on Mac OS X can take advantage of \c{qmake}'s support for Xcode
832
project files, as described in
833
\l{Qt is Mac OS X Native#Development Tools}{Qt is Mac OS X Native},
834
by running \c qmake to generate an Xcode project from an existing \c qmake
835
project files. For example:
837
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 19
839
Note that, if a project is later moved on the disk, \c qmake must be run
840
again to process the project file and create a new Xcode project file.
842
\section2 On supporting two build targets simultaneously
844
Implementing this is currently not feasible, because the XCode
845
concept of Active Build Configurations is conceptually different
846
from the qmake idea of build targets.
848
The XCode Active Build Configurations settings are for modifying
849
xcode configurations, compiler flags and similar build
850
options. Unlike Visual Studio, XCode does not allow for the
851
selection of specific library files based on whether debug or
852
release build configurations are selected. The qmake debug and
853
release settings control which library files are linked to the
856
It is currently not possible to set files in XCode configuration
857
settings from the qmake generated xcode project file. The way the
858
libraries are linked in the "Frameworks & Libraries" phase in the
861
Furthermore, The selected "Active Build Configuration" is stored
862
in a .pbxuser file, which is generated by xcode on first load, not
867
Features specific to this platform include support for creating Visual
868
Studio project files and handling manifest files when deploying Qt
869
applications developed using Visual Studio 2005.
871
\section2 Creating Visual Studio Project Files
873
Developers using Visual Studio to write Qt applications can use the
874
Visual Studio integration facilities provided with the
875
\l{Qt Commercial Editions} and do not need to worry about how
876
project dependencies are managed.
878
However, some developers may need to import an existing \c qmake project
879
into Visual Studio. \c qmake is able to take a project file and create a
880
Visual Studio project that contains all the necessary information required
881
by the development environment. This is achieved by setting the \c qmake
882
\l{qmake Variable Reference#TEMPLATE}{project template} to either \c vcapp
883
(for application projects) or \c vclib (for library projects).
885
This can also be set using a command line option, for example:
887
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 20
889
It is possible to recursively generate \c{.vcproj} files in subdirectories
890
and a \c{.sln} file in the main directory, by typing:
892
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 21
894
Each time you update the project file, you need to run \c qmake to generate
895
an updated Visual Studio project.
897
\note If you are using the Visual Studio Add-in, you can import \c .pro
898
files via the \gui{Qt->Import from .pro file} menu item.
900
\section2 Visual Studio 2005 Manifest Files
902
When deploying Qt applications built using Visual Studio 2005, it is
903
necessary to ensure that the manifest file, created when the application
904
was linked, is handled correctly. This is handled automatically for
905
projects that generate DLLs.
907
Removing manifest embedding for application executables can be done with
908
the following assignment to the \l{qmake Variable Reference#CONFIG}
911
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 22
913
Also, the manifest embedding for DLLs can be removed with the following
914
assignment to the \l{qmake Variable Reference#CONFIG}{CONFIG} variable:
916
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 23
918
This is discussed in more detail in the
919
\l{Deploying an Application on Windows#Visual Studio 2005 Onwards}
920
{deployment guide for Windows}.
923
\section1 Symbian platform
925
Features specific to this platform include handling of static data,
926
capabilities, stack and heap size, compiler specific options, and unique
927
identifiers for the application or library.
929
\section2 Handling of static data
931
If the application uses any static data, the build system needs to be
932
informed about it. This is because Symbian tries to save memory if no
933
static data is in use.
935
To specify that static data support is desired, add this to the project file:
937
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 129
939
The default value is zero.
941
\section2 Stack and heap size
943
The Symbian platform uses predefined sizes for stacks and heaps. If an
944
application exceeds either limit, it may crash or fail to complete its
945
task. Crashes that seem to have no reason can often be traced back to
946
insufficient stack and/or heap sizes.
948
The stack size has a maximum value, whereas the heap size has a
949
minimum and a maximum value, all specified in bytes. The minimum value
950
prevents the application from starting if that amount of memory is not available. The
951
minimum and maximum values are separated by a space. For example:
953
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 130
955
The default values depend on the version of the Symbian SDK you're using.
957
\section2 Compiler specific options
959
General compiler options can as usual be set using \c QMAKE_CFLAGS and \c QMAKE_CXXFLAGS.
960
In order to set specific compiler options, \c QMAKE_CFLAGS.<compiler> and
961
\c QMAKE_CXXFLAGS.<compiler> can be used. \c <compiler> can be either \c CW for the WINSCW
962
architecture (emulator), or \c ARMCC for the ARMv5 architecture (hardware), or \c GCCE for
963
the ARMv5 architecture (hardware).
967
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 131
969
\section2 Unique identifiers
971
Symbian applications may have unique identifiers attached to them.
972
Here is how to define them in a project file:
974
There are four types of IDs supported: \c UID2, \c UID3, \c SID, and \c VID. They
975
are specified like this:
977
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 132
979
If \c UID2 is not specified, it defaults to the same value as \c UID3.
980
If \c UID3 is not specified, qmake will automatically generate a \c UID3
981
suitable for development and debugging. This value should be manually
982
specified for applications that are to be released. In order to optain
983
an official UID, please contact Nokia. Both \c SID and \c VID default to empty values.
985
For more information about unique identifiers and their meaning for
986
Symbian applications, please refer to the Symbian SDK documentation.
988
\section2 Capabilities
990
Capabilities define extra priviledges for the application, such as the
991
ability to list all files on the file system. Capabilities are defined
992
in the project file like this:
994
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 133
996
It is also possible to specify which capabilities \e not to have,
997
by first specifying \c ALL and then list the unwanted capabilities
998
with a minus in front of them, like this:
1000
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 134
1002
For more information about capabilities, please refer to the Symbian SDK documentation.
1006
\page qmake-reference.html
1007
\title qmake Reference
1008
\contentspage {qmake Manual}{Contents}
1009
\previouspage Using Precompiled Headers
1010
\nextpage qmake Variable Reference
1012
This reference is a detailed index of all the variables and function
1013
that are available for use in \c qmake project files.
1015
\section1 Variable Reference
1017
The \l{qmake Variable Reference} describes the variables that are
1018
recognized by \c qmake when configuring the build process for
1021
\section1 Function Reference
1023
The \l{qmake Function Reference} describes the function that can be
1024
used to process the contents of variables defined in project files.
1026
\target FrequentlyUsedVariables
1027
\section1 Frequently Used Variables
1029
The following variables are frequently used in project files to describe
1030
common aspects of the build process. These are fully described in the
1031
\l{qmake-variable-reference.html}{Variable Reference}.
1034
\o \l{qmake Variable Reference#CONFIG}{CONFIG}
1035
\o \l{qmake Variable Reference#DEF_FILE}{DEF_FILE}
1036
\o \l{qmake Variable Reference#DEFINES}{DEFINES}
1037
\o \l{qmake Variable Reference#DESTDIR}{DESTDIR}
1038
\o \l{qmake Variable Reference#DISTFILES}{DISTFILES}
1039
\o \l{qmake Variable Reference#DLLDESTDIR}{DLLDESTDIR}
1040
\o \l{qmake Variable Reference#FORMS}{FORMS}
1041
\o \l{qmake Variable Reference#FORMS3}{FORMS3}
1042
\o \l{qmake Variable Reference#GUID}{GUID}
1043
\o \l{qmake Variable Reference#HEADERS}{HEADERS}
1044
\o \l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH}
1045
\o \l{qmake Variable Reference#LEXSOURCES}{LEXSOURCES}
1046
\o \l{qmake Variable Reference#LIBS}{LIBS}
1047
\o \l{qmake Variable Reference#MOC_DIR}{MOC_DIR}
1048
\o \l{qmake Variable Reference#OBJECTS_DIR}{OBJECTS_DIR}
1049
\o \l{qmake Variable Reference#QT}{QT}
1050
\o \l{qmake Variable Reference#RCC_DIR}{RCC_DIR}
1051
\o \l{qmake Variable Reference#REQUIRES}{REQUIRES}
1052
\o \l{qmake Variable Reference#RESOURCES}{RESOURCES}
1053
\o \l{qmake Variable Reference#SOURCES}{SOURCES}
1054
\o \l{qmake Variable Reference#SUBDIRS}{SUBDIRS}
1055
\o \l{qmake Variable Reference#TARGET}{TARGET}
1056
\o \l{qmake Variable Reference#TEMPLATE}{TEMPLATE}
1057
\o \l{qmake Variable Reference#TRANSLATIONS}{TRANSLATIONS}
1058
\o \l{qmake Variable Reference#UI_DIR}{UI_DIR}
1059
\o \l{qmake Variable Reference#UI_HEADERS_DIR}{UI_HEADERS_DIR}
1060
\o \l{qmake Variable Reference#UI_SOURCES_DIR}{UI_SOURCES_DIR}
1061
\o \l{qmake Variable Reference#VERSION}{VERSION}
1062
\o \l{qmake Variable Reference#YACCSOURCES}{YACCSOURCES}
1065
\section1 Environment Variables and Configuration
1067
The \l{Configuring qmake's Environment} chapter of this manual
1068
describes the environment variables that \c qmake uses when
1069
configuring the build process.
1073
\page qmake-variable-reference.html
1074
\title qmake Variable Reference
1075
\contentspage {qmake Manual}{Contents}
1076
\previouspage qmake Reference
1077
\nextpage qmake Function Reference
1079
\c{qmake}'s fundamental behavior is influenced by variable declarations that
1080
define the build process of each project. Some of these declare resources,
1081
such as headers and source files, that are common to each platform; others
1082
are used to customize the behavior of compilers and linkers on specific
1085
Platform-specific variables follow the naming pattern of the
1086
variables which they extend or modify, but include the name of the relevant
1087
platform in their name. For example, \c QMAKE_LIBS can be used to specify a list
1088
of libraries that a project needs to link against, and \c QMAKE_LIBS_X11 can be
1089
used to extend or override this list.
1093
\target BLD_INF_RULES
1094
\section1 BLD_INF_RULES
1096
\e {This is only used on the Symbian platform.}
1098
Generic \c bld.inf file content can be specified with \c BLD_INF_RULES variables.
1099
The section of \c bld.inf file where each rule goes is appended to
1100
\c BLD_INF_RULES with a dot.
1104
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 146
1106
This will add the specified statements to the \c prj_exports section of the
1107
generated \c bld.inf file.
1109
It is also possible to add multiple rows in a single block. Each double
1110
quoted string will be placed on a new row in the generated \c bld.inf file.
1114
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 143
1116
Any rules you define will be added after automatically generated
1117
rules in each section.
1122
The \c CONFIG variable specifies project configuration and
1123
compiler options. The values will be recognized internally by
1124
\c qmake and have special meaning. They are as follows.
1126
These \c CONFIG values control compilation flags:
1129
\header \o Option \o Description
1130
\row \o release \o The project is to be built in release mode.
1131
This is ignored if \c debug is also specified.
1132
\row \o debug \o The project is to be built in debug mode.
1133
\row \o debug_and_release \o The project is built in \e both debug and
1134
release modes. This can have some unexpected side effects (see
1135
below for more information).
1136
\row \o build_all \o If \c debug_and_release is specified, the project is
1137
built in both debug and release modes by default.
1138
\row \o ordered \o When using the \c subdirs template, this option
1139
specifies that the directories listed should be processed in the
1140
order in which they are given.
1141
\row \o precompile_header \o Enables support for the use of
1142
\l{Using Precompiled Headers}{precompiled headers} in projects.
1143
\row \o warn_on \o The compiler should output as many warnings as possible.
1144
This is ignored if \c warn_off is specified.
1145
\row \o warn_off \o The compiler should output as few warnings as possible.
1147
\row \o qt_debug \o Specifies that the project should be built against
1148
debug versions of the Qt libraries specified using the
1149
\l{#QT}{QT} variable.
1150
\row \o qt_release \o Specifies that the project should be built against
1151
release versions of the Qt libraries specified using the
1152
\l{#QT}{QT} variable.
1156
Since the \c debug option overrides the \c release option when both are
1157
defined in the \c CONFIG variable, it is necessary to use the
1158
\c debug_and_release option if you want to allow both debug and release
1159
versions of a project to be built. In such a case, the Makefile that
1160
\c qmake generates includes a rule that builds both versions, and this can
1161
be invoked in the following way:
1163
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 24
1165
When linking a library, \c qmake relies on the underlying platform to know
1166
what other libraries this library links against. However, if linking
1167
statically, \c qmake will not get this information unless we use the following
1171
\header \o Option \o Description
1172
\row \o create_prl \o This option enables \c qmake to track these
1173
dependencies. When this option is enabled, \c qmake will create a file
1174
ending in \c .prl which will save meta-information about the library
1175
(see \l{LibDepend}{Library Dependencies} for more info).
1176
\row \o link_prl \o When this is enabled, \c qmake will process all
1177
libraries linked to by the application and find their meta-information
1178
(see \l{LibDepend}{Library Dependencies} for more info).
1181
Please note that \c create_prl is required when \e {building} a
1182
static library, while \c link_prl is required when \e {using} a
1185
On Windows (or if Qt is configured with \c{-debug_and_release}, adding the
1186
\c build_all option to the \c CONFIG variable makes this rule the default
1187
when building the project, and installation targets will be created for
1188
both debug and release builds.
1190
Additionally, adding \c debug_and_release to the \c CONFIG variable will
1191
cause both \c debug and \c release to be defined in the contents of
1192
\c CONFIG. When the project file is processed, the
1193
\l{qmake Advanced Usage#Scopes}{scopes} that test for each value will be
1194
processed for \e both debug and release modes. The \c{build_pass} variable
1195
will be set for each of these mode, and you can test for this to perform
1196
build-specific tasks. For example:
1198
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 25
1200
As a result, it may be useful to define mode-specific variables, such as
1201
\l{#QMAKE_LFLAGS_RELEASE}{QMAKE_LFLAGS_RELEASE}, instead of general
1202
variables, such as \l{#QMAKE_LFLAGS}{QMAKE_LFLAGS}, where possible.
1204
The following options define the application/library type:
1207
\header \o Option \o Description
1208
\row \o qt \o The target is a Qt application/library and requires the Qt
1209
library and header files. The proper include and library paths for the
1210
Qt library will automatically be added to the project. This is defined
1211
by default, and can be fine-tuned with the \c{\l{#qt}{QT}} variable.
1212
\row \o thread \o The target is a multi-threaded application or library. The
1213
proper defines and compiler flags will automatically be added to
1215
\row \o x11 \o The target is a X11 application or library. The proper
1216
include paths and libraries will automatically be added to the
1218
\row \o windows \o The target is a Win32 window application (app only). The
1219
proper include paths, compiler flags and libraries will
1220
automatically be added to the project.
1221
\row \o console \o The target is a Win32 console application (app only). The
1222
proper include paths, compiler flags and libraries will
1223
automatically be added to the
1225
\row \o shared \o{1,3} The target is a shared object/DLL. The proper
1226
include paths, compiler flags and libraries will automatically be
1227
added to the project.
1230
\row \o static \o{1,2} The target is a static library (lib only). The proper
1231
compiler flags will automatically be added to the project.
1232
\row \o staticlib \o
1233
\row \o plugin \o The target is a plugin (lib only). This enables dll as well.
1234
\row \o designer \o The target is a plugin for \QD.
1235
\row \o uic3 \o Configures qmake to run uic3 on the content of \c FORMS3 if
1236
defined; otherwise the contents of \c FORMS will be processed instead.
1237
\row \o no_lflags_merge \o Ensures that the list of libraries stored in the
1238
\c LIBS variable is not reduced to a list of unique values before it is used.
1239
\row \o resources \o Configures qmake to run rcc on the content of \c RESOURCES
1243
These options are used to set the compiler flags:
1246
\header \o Option \o Description
1247
\row \o 3dnow \o AMD 3DNow! instruction support is enabled.
1248
\row \o exceptions \o Exception support is enabled.
1249
\row \o mmx \o Intel MMX instruction support is enabled.
1250
\row \o rtti \o RTTI support is enabled.
1251
\row \o stl \o STL support is enabled.
1252
\row \o sse \o SSE support is enabled.
1253
\row \o sse2 \o SSE2 support is enabled.
1256
These options define specific features on Windows only:
1259
\header \o Option \o Description
1260
\row \o flat \o When using the vcapp template this will put all the source
1261
files into the source group and the header files into the header group
1262
regardless of what directory they reside in. Turning this
1263
option off will group the files within the source/header group depending
1264
on the directory they reside. This is turned on by default.
1265
\row \o embed_manifest_dll \o Embeds a manifest file in the DLL created
1266
as part of a library project.
1267
\row \o embed_manifest_exe \o Embeds a manifest file in the DLL created
1268
as part of an application project.
1269
\row \o incremental \o Used to enable or disable incremental linking in Visual
1270
C++, depending on whether this feature is enabled or disabled by default.
1273
See \l{qmake Platform Notes#Visual Studio 2005 Manifest Files}{qmake Platform Notes}
1274
for more information on the options for embedding manifest files.
1276
These options only have an effect on Mac OS X:
1279
\header \o Option \o Description
1280
\row \o ppc \o Builds a PowerPC binary.
1281
\row \o x86 \o Builds an i386 compatible binary.
1282
\row \o app_bundle \o Puts the executable into a bundle (this is the default).
1283
\row \o lib_bundle \o Puts the library into a library bundle.
1286
The build process for bundles is also influenced by
1287
the contents of the \l{#QMAKE_BUNDLE_DATA}{QMAKE_BUNDLE_DATA} variable.
1289
These options only have an effect on the Symbian platform:
1292
\header \o Option \o Description
1293
\row \o stdbinary \o Builds an Open C binary (i.e. STDDLL, STDEXE, or STDLIB,
1294
depending on the target binary type.)
1295
\row \o no_icon \o Doesn't generate resources needed for displaying an icon
1296
for executable in application menu (app only).
1297
\row \o symbian_test \o Places mmp files and extension makefiles under
1298
test sections in generated bld.inf instead of their regular sections.
1299
Note that this only affects automatically generated bld.inf content;
1300
the content added via \c BLD_INF_RULES variable is not affected.
1303
These options have an effect on Linux/Unix platforms:
1306
\header \o Option \o Description
1307
\row \o largefile \o Includes support for large files.
1308
\row \o separate_debug_info \o Puts debugging information for libraries in
1312
The \c CONFIG variable will also be checked when resolving scopes. You may
1313
assign anything to this variable.
1317
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 26
1322
\c qmake adds the values of this variable as compiler C
1323
preprocessor macros (-D option).
1327
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 27
1332
\e {This is only used on Windows when using the \c app template}.
1334
Specifies a \c .def file to be included in the project.
1337
\section1 DEPENDPATH
1339
This variable contains the list of all directories to look in to
1340
resolve dependencies. This will be used when crawling through
1344
\section1 DEPLOYMENT
1346
\e {This is only used on Windows CE and the Symbian platform.}
1348
Specifies which additional files will be deployed. Deployment means the
1349
transfer of files from the development system to the target device or
1352
Files can be deployed by either creating a Visual Studio project or using
1353
the \l {Using QTestLib remotely on Windows CE}{cetest} executable.
1357
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 28
1359
This will upload all PNG images in \c path to the same directory your
1360
build target will be deployed to.
1362
The default deployment target path for Windows CE is
1363
\c{%CSIDL_PROGRAM_FILES%\target}, which usually gets expanded to
1364
\c{\Program Files\target}. For the Symbian platform, the default target
1365
is the application private directory on the drive it is installed to.
1367
It is also possible to specify multiple \c sources to be deployed on
1368
target \c paths. In addition, different variables can be used for
1369
deployment to different directories.
1373
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 29
1375
\note In Windows CE all linked Qt libraries will be deployed to the path
1376
specified by \c{myFiles.path}. On Symbian platform all libraries and executables
1377
will always be deployed to the \\sys\\bin of the installation drive.
1379
Since the Symbian platform build system automatically moves binaries to certain
1380
directories under the epoc32 directory, custom plugins, executables or
1381
dynamically loadable libraries need special handling. When deploying
1382
extra executables or dynamically loadable libraries, the target path
1383
must specify \\sys\\bin. For plugins, the target path must specify the
1384
location where the plugin stub will be deployed to (see the
1385
\l{How to Create Qt Plugins} document for more information about plugins).
1386
If the binary cannot be found from the indicated source path,
1387
the directory Symbian build process moves the executables to is
1388
searched, e.g. \\epoc32\\release\\armv5\\urel.
1392
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 128
1394
On the Symbian platform, generic PKG file content can also be specified with this
1395
variable. You can use either \c pkg_prerules or \c pkg_postrules to
1396
pass raw data to PKG file. The strings in \c pkg_prerules are added before
1397
package-body and \c pkg_postrules after. The strings defined in
1398
\c pkg_postrules or \c pkg_prerules are not parsed by qmake, so they
1399
should be in a format understood by Symbian package generation tools.
1400
Please consult the Symbian platform documentation for correct syntax.
1402
For example, to deploy DLL and add a new dependency:
1404
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 140
1406
Please note that \c pkg_prerules can also replace default statements in
1407
pkg file. If no pkg_prerules is defined, qmake makes sure that PKG file
1408
syntax is correct and it contains all mandatory statements such as:
1411
\o languages, for example \BR
1413
\o package-header, for example \BR
1414
#{"MyApp-EN", "MyApp-FR"}, (0x1000001F), 1, 2, 3, TYPE=SA
1415
\o localized and unique vendor, for example \BR
1416
%{"Vendor-EN", ..., "Vendor-FR"}
1417
:"Unique vendor name"
1420
If you decide to override any of these statements, you need to pay
1421
attention that also other statements stay valid. For example if you
1422
override languages statement, you must override also package-header
1423
statement and all other statements which are language specific.
1425
On the Symbian platform, the \c default_deployment item specifies
1426
default platform dependencies. It can be overwritten if a more
1427
restrictive set is needed - e.g. if a specific
1428
device is required to run the application.
1432
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 141
1434
\target DEPLOYMENT_PLUGIN
1435
\section1 DEPLOYMENT_PLUGIN
1437
\e {This is only used on Windows CE and the Symbian platform.}
1439
This variable specifies the Qt plugins that will be deployed. All plugins
1440
available in Qt can be explicitly deployed to the device. See
1441
\l{Static Plugins}{Static Plugins} for a complete list.
1443
\note In Windows CE, No plugins will be deployed automatically.
1444
If the application depends on plugins, these plugins have to be specified
1447
\note On the Symbian platform, all plugins supported by this variable
1448
will be deployed by default with Qt libraries, so generally using this
1449
variable is not needed.
1453
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 142
1455
This will upload the jpeg imageformat plugin to the plugins directory
1456
on the Windows CE device.
1461
Specifies where to put the \l{#TARGET}{target} file.
1465
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 30
1467
\target DESTDIR_TARGET
1468
\section1 DESTDIR_TARGET
1470
This variable is set internally by \c qmake, which is basically the
1471
\c DESTDIR variable with the \c TARGET variable appened at the end.
1472
The value of this variable is typically handled by \c qmake or
1473
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
1476
\section1 DLLDESTDIR
1478
Specifies where to copy the \l{#TARGET}{target} dll.
1483
This variable contains a list of files to be included in the dist
1484
target. This feature is supported by UnixMake specs only.
1488
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 31
1490
\target DSP_TEMPLATE
1491
\section1 DSP_TEMPLATE
1493
This variable is set internally by \c qmake, which specifies where the
1494
dsp template file for basing generated dsp files is stored. The value
1495
of this variable is typically handled by \c qmake or
1496
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
1501
This variable specifies the UI files (see \link
1502
designer-manual.html Qt Designer \endlink) to be processed through \c uic
1503
before compiling. All dependencies, headers and source files required
1504
to build these UI files will automatically be added to the project.
1508
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 32
1510
If FORMS3 is defined in your project, then this variable must contain
1511
forms for uic, and not uic3. If CONFIG contains uic3, and FORMS3 is not
1512
defined, the this variable must contain only uic3 type forms.
1517
This variable specifies the old style UI files to be processed
1518
through \c uic3 before compiling, when \c CONFIG contains uic3.
1519
All dependencies, headers and source files required to build these
1520
UI files will automatically be added to the project.
1524
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 33
1529
Specifies the GUID that is set inside a \c{.vcproj} file. The GUID is
1530
usually randomly determined. However, should you require a fixed GUID,
1531
it can be set using this variable.
1533
This variable is specific to \c{.vcproj} files only; it is ignored
1539
Defines the header files for the project.
1541
\c qmake will generate dependency information (unless \c -nodepend
1542
is specified on the \l{Running qmake#Commands}{command line})
1543
for the specified headers. \c qmake will also automatically detect if
1544
\c moc is required by the classes in these headers, and add the
1545
appropriate dependencies and files to the project for generating and
1546
linking the moc files.
1550
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 34
1552
See also \l{#SOURCES}{SOURCES}.
1557
This variable is used only in MAC and the Symbian platform to set the application icon.
1558
Please see \l{Setting the Application Icon}{the application icon documentation}
1559
for more information.
1562
\section1 INCLUDEPATH
1564
This variable specifies the #include directories which should be
1565
searched when compiling the project. Use ';' or a space as the
1566
directory separator.
1570
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 35
1572
To specify a path containing spaces, quote the path using the technique
1573
mentioned in the \l{qmake Project Files#Whitespace}{qmake Project Files}
1574
document. For example, paths with spaces can be specified on Windows
1575
and Unix platforms by using the \l{qmake Function Reference#quote-string}{quote()}
1576
function in the following way:
1578
\snippet doc/src/snippets/qmake/spaces.pro quoting include paths with spaces
1583
This variable contains a list of resources that will be installed when
1584
\c{make install} or a similar installation procedure is executed. Each
1585
item in the list is typically defined with attributes that provide
1586
information about where it will be installed.
1588
For example, the following \c{target.path} definition describes where the
1589
build target will be installed, and the \c INSTALLS assignment adds the
1590
build target to the list of existing resources to be installed:
1592
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 36
1597
This variable contains a list of lex implementation files. The value
1598
of this variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
1599
needs to be modified.
1602
\section1 LEXOBJECTS
1604
This variable contains the names of intermediate lex object
1605
files.The value of this variable is typically handled by
1606
\c qmake and rarely needs to be modified.
1609
\section1 LEXSOURCES
1611
This variable contains a list of lex source files. All
1612
dependencies, headers and source files will automatically be added to
1613
the project for building these lex files.
1617
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 37
1622
This variable contains a list of libraries to be linked into the project.
1623
You can use the Unix \c -l (library) and -L (library path) flags and qmake
1624
will do the correct thing with these libraries on Windows and the
1625
Symbian platform (namely this means passing the full path of the library to
1626
the linker). The only limitation to this is the library must exist, for
1627
qmake to find which directory a \c -l lib lives in.
1631
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 38
1633
To specify a path containing spaces, quote the path using the technique
1634
mentioned in the \l{qmake Project Files#Whitespace}{qmake Project Files}
1635
document. For example, paths with spaces can be specified on Windows
1636
and Unix platforms by using the \l{qmake Function Reference#quote-string}{quote()}
1637
function in the following way:
1639
\snippet doc/src/snippets/qmake/spaces.pro quoting library paths with spaces
1641
\bold{Note:} On Windows, specifying libraries with the \c{-l} option,
1642
as in the above example, will cause the library with the highest version
1643
number to be used; for example, \c{libmath2.lib} could potentially be used
1644
instead of \c{libmathlib}. To avoid this ambiguity, we recommend that you
1645
explicitly specify the library to be used by including the \c{.lib}
1648
\bold{Note:} On the Symbian platform, the build system makes a
1649
distinction between shared and
1650
static libraries. In most cases, qmake will figure out which library you
1651
are refering to, but in some cases you may have to specify it explicitly to
1652
get the expected behavior. This typically happens if you are building a
1653
library and using it in the same project. To specify that the library is
1654
either shared or static, add a ".dll" or ".lib" suffix, respectively, to the
1657
By default, the list of libraries stored in \c LIBS is reduced to a list of
1658
unique names before it is used. To change this behavior, add the
1659
\c no_lflags_merge option to the \c CONFIG variable:
1661
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 39
1663
\target LITERAL_HASH
1664
\section1 LITERAL_HASH
1666
This variable is used whenever a literal hash character (\c{#}) is needed in
1667
a variable declaration, perhaps as part of a file name or in a string passed
1668
to some external application.
1672
\snippet doc/src/snippets/qmake/comments.pro 1
1674
By using \c LITERAL_HASH in this way, the \c # character can be used
1675
to construct a URL for the \c message() function to print to the console.
1680
This variable specifies the name of the Makefile which
1681
\c qmake should use when outputting the dependency information
1682
for building a project. The value of this variable is typically
1683
handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
1685
\target MAKEFILE_GENERATOR
1686
\section1 MAKEFILE_GENERATOR
1688
This variable contains the name of the Makefile generator to use
1689
when generating a Makefile. The value of this variable is typically
1690
handled internally by \c qmake and rarely needs to be modified.
1695
\e {This is only used on the Symbian platform.}
1697
Generic MMP file content can be specified with this variable.
1701
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 137
1703
This will add the specified statement to the end of the generated MMP file.
1705
It is also possible to add multiple rows in a single block. Each double
1706
quoted string will be placed on a new row in the generated MMP file.
1710
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 138
1712
If you need to include a hash (\c{#}) character inside the
1713
\c MMP_RULES statement, it can be done with the variable
1714
\c LITERAL_HASH as follows:
1716
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 139
1718
\note You should not use this variable to add MMP statements that are
1719
explicitly supported by their own variables, such as
1720
\c TARGET.EPOCSTACKSIZE.
1721
Doing so could result in duplicate statements in the MMP file.
1726
This variable specifies the directory where all intermediate moc
1727
files should be placed.
1731
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 40
1736
This variable is generated from the \link #SOURCES SOURCES
1737
\endlink variable. The extension of each source file will have been
1738
replaced by .o (Unix) or .obj (Win32). The value of this variable is
1739
typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and
1740
rarely needs to be modified.
1743
\section1 OBJECTS_DIR
1745
This variable specifies the directory where all intermediate
1746
objects should be placed.
1750
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 41
1755
This variable is set by \c qmake if files can be found that
1756
contain the Q_OBJECT macro. \c OBJMOC contains the
1757
name of all intermediate moc object files. The value of this variable
1758
is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
1761
\target POST_TARGETDEPS
1762
\section1 POST_TARGETDEPS
1764
All libraries that the \l{#TARGET}{target} depends on can be
1765
listed in this variable. Some backends do not support this, these include
1766
MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is supported
1767
internally by these build tools, this is useful for explicitly listing
1768
dependant static libraries.
1770
This list will go after all builtin (and \link #PRE_TARGETDEPS
1771
$$PRE_TARGETDEPS \endlink) dependencies.
1773
\target PRE_TARGETDEPS
1774
\section1 PRE_TARGETDEPS
1776
All libraries that the \l{#TARGET}{target} depends on can be
1777
listed in this variable. Some backends do not support this, these include
1778
MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is supported
1779
internally by these build tools, this is useful for explicitly listing
1780
dependant static libraries.
1782
This list will go before all builtin dependencies.
1784
\target PRECOMPILED_HEADER
1785
\section1 PRECOMPILED_HEADER
1787
This variable indicates the header file for creating a precompiled
1788
header file, to increase the compilation speed of a project.
1789
Precompiled headers are currently only supported on some platforms
1790
(Windows - all MSVC project types, Mac OS X - Xcode, Makefile,
1791
Unix - gcc 3.3 and up).
1793
On other platforms, this variable has different meaning, as noted
1796
This variable contains a list of header files that require some
1797
sort of pre-compilation step (such as with moc). The value of this
1798
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
1804
This variable contains the full path leading to the directory where
1805
the \c qmake project file (project.pro) is located.
1810
This variable contains the full path leading to the directory where
1811
\c qmake places the generated Makefile.
1813
\target QMAKE_systemvariable
1816
This variable contains the name of the \c qmake program
1817
itself and is placed in generated Makefiles. The value of this
1818
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
1821
\target QMAKESPEC_systemvariable
1824
This variable contains the name of the \c qmake
1825
configuration to use when generating Makefiles. The value of this
1826
variable is typically handled by \c qmake and rarely needs to be modified.
1828
Use the \c{QMAKESPEC} environment variable to override the \c qmake configuration.
1829
Note that, due to the way \c qmake reads project files, setting the \c{QMAKESPEC}
1830
environment variable from within a project file will have no effect.
1832
\target QMAKE_APP_FLAG
1833
\section1 QMAKE_APP_FLAG
1835
This variable is empty unless the \c app
1836
\l{#TEMPLATE}{TEMPLATE} is specified. The value of this
1837
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
1838
modified. Use the following instead:
1840
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 42
1842
\target QMAKE_APP_OR_DLL
1843
\section1 QMAKE_APP_OR_DLL
1845
This variable is empty unless the \c app or \c dll
1846
\l{#TEMPLATE}{TEMPLATE} is specified. The value of this
1847
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
1850
\target QMAKE_AR_CMD
1851
\section1 QMAKE_AR_CMD
1853
\e {This is used on Unix platforms only.}
1855
This variable contains the command for invoking the program which
1856
creates, modifies and extracts archives. The value of this variable is
1857
typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf}
1858
and rarely needs to be modified.
1860
\target QMAKE_BUNDLE_DATA
1861
\section1 QMAKE_BUNDLE_DATA
1863
This variable is used to hold the data that will be installed with a library
1864
bundle, and is often used to specify a collection of header files.
1866
For example, the following lines add \c path/to/header_one.h
1867
and \c path/to/header_two.h to a group containing information about the
1868
headers supplied with the framework:
1870
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 43
1872
The last line adds the information about the headers to the collection of
1873
resources that will be installed with the library bundle.
1875
Library bundles are created when the \c lib_bundle option is added to the
1876
\l{#CONFIG}{CONFIG} variable.
1878
See \l{qmake Platform Notes#Creating Frameworks}{qmake Platform Notes} for
1879
more information about creating library bundles.
1881
\e{This is used on Mac OS X only.}
1883
\section1 QMAKE_BUNDLE_EXTENSION
1885
This variable defines the extension to be used for library bundles.
1886
This allows frameworks to be created with custom extensions instead of the
1887
standard \c{.framework} directory name extension.
1889
For example, the following definition will result in a framework with the
1890
\c{.myframework} extension:
1892
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 44
1894
\e{This is used on Mac OS X only.}
1898
This variable specifies the C compiler that will be used when building
1899
projects containing C source code. Only the file name of the compiler
1900
executable needs to be specified as long as it is on a path contained
1901
in the \c PATH variable when the Makefile is processed.
1903
\target QMAKE_CFLAGS_DEBUG
1904
\section1 QMAKE_CFLAGS_DEBUG
1906
This variable contains the flags for the C compiler in debug mode.The value of this variable is
1907
typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf}
1908
and rarely needs to be modified.
1910
\target QMAKE_CFLAGS_MT
1911
\section1 QMAKE_CFLAGS_MT
1913
This variable contains the compiler flags for creating a
1914
multi-threaded application or when the version of Qt that you link
1915
against is a multi-threaded statically linked library. The value of
1916
this variable is typically handled by \c qmake or
1917
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
1919
\target QMAKE_CFLAGS_MT_DBG
1920
\section1 QMAKE_CFLAGS_MT_DBG
1922
This variable contains the compiler flags for creating a debuggable
1923
multi-threaded application or when the version of Qt that you link
1924
against is a debuggable multi-threaded statically linked library. The
1925
value of this variable is typically handled by \c qmake or
1926
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
1928
\target QMAKE_CFLAGS_MT_DLL
1929
\section1 QMAKE_CFLAGS_MT_DLL
1931
\e {This is used on Windows only.}
1933
This variable contains the compiler flags for creating a
1934
multi-threaded dll or when the version of Qt that you link
1935
against is a multi-threaded dll. The value of this variable is typically
1936
handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and
1937
rarely needs to be modified.
1939
\target QMAKE_CFLAGS_MT_DLLDBG
1940
\section1 QMAKE_CFLAGS_MT_DLLDBG
1942
\e {This is used on Windows only.}
1944
This variable contains the compiler flags for creating a debuggable
1945
multi-threaded dll or when the version of Qt that you link
1946
against is a debuggable multi-threaded statically linked library.
1947
The value of this variable is typically handled by \c qmake or
1948
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
1950
\target QMAKE_CFLAGS_RELEASE
1951
\section1 QMAKE_CFLAGS_RELEASE
1953
This variable contains the compiler flags for creating a non-debuggable
1954
application. The value of this variable is typically
1955
handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and
1956
rarely needs to be modified.
1958
\target QMAKE_CFLAGS_SHLIB
1959
\section1 QMAKE_CFLAGS_SHLIB
1961
\e {This is used on Unix platforms only.}
1963
This variable contains the compiler flags for creating a shared
1964
library. The value of this variable is typically handled by
1965
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
1968
\target QMAKE_CFLAGS_THREAD
1969
\section1 QMAKE_CFLAGS_THREAD
1971
This variable contains the compiler flags for creating a multi-threaded
1972
application. The value of this variable is typically handled by
1973
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
1976
\target QMAKE_CFLAGS_WARN_OFF
1977
\section1 QMAKE_CFLAGS_WARN_OFF
1979
This variable is not empty if the warn_off
1980
\l{#TEMPLATE}{TEMPLATE} option is specified. The value of this
1981
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf}
1982
and rarely needs to be modified.
1984
\target QMAKE_CFLAGS_WARN_ON
1985
\section1 QMAKE_CFLAGS_WARN_ON
1987
This variable is not empty if the warn_on
1988
\l{#TEMPLATE}{TEMPLATE} option is specified.
1989
The value of this variable is typically handled by
1990
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
1994
\section1 QMAKE_CLEAN
1996
This variable contains any files which are not generated files (such as moc and uic
1997
generated files) and object files that should be removed when using "make clean".
2001
This variable specifies the C++ compiler that will be used when building
2002
projects containing C++ source code. Only the file name of the compiler
2003
executable needs to be specified as long as it is on a path contained
2004
in the \c PATH variable when the Makefile is processed.
2006
\section1 QMAKE_CXXFLAGS
2008
This variable contains the C++ compiler flags that are used when building
2009
a project. The value of this variable is typically handled by \c qmake or
2010
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified. The flags
2011
specific to debug and release modes can be adjusted by modifying
2012
the \c QMAKE_CXXFLAGS_DEBUG and \c QMAKE_CXXFLAGS_RELEASE variables,
2015
\bold{Note:} On the Symbian platform, this variable can be used to pass
2016
architecture specific options to each compiler in the Symbian build system.
2019
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 131
2021
For more information, see
2022
\l{qmake Platform Notes#Compiler specific options}{qmake Platform Notes}.
2024
\target QMAKE_CXXFLAGS_DEBUG
2025
\section1 QMAKE_CXXFLAGS_DEBUG
2027
This variable contains the C++ compiler flags for creating a debuggable
2028
application. The value of this variable is typically handled by
2029
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2032
\target QMAKE_CXXFLAGS_MT
2033
\section1 QMAKE_CXXFLAGS_MT
2035
This variable contains the C++ compiler flags for creating a multi-threaded
2036
application. The value of this variable is typically handled by
2037
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2040
\target QMAKE_CXXFLAGS_MT_DBG
2041
\section1 QMAKE_CXXFLAGS_MT_DBG
2043
This variable contains the C++ compiler flags for creating a debuggable multi-threaded
2044
application. The value of this variable is typically handled by
2045
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2048
\target QMAKE_CXXFLAGS_MT_DLL
2049
\section1 QMAKE_CXXFLAGS_MT_DLL
2051
\c {This is used on Windows only.}
2053
This variable contains the C++ compiler flags for creating a multi-threaded
2054
dll. The value of this variable is typically handled by
2055
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2058
\target QMAKE_CXXFLAGS_MT_DLLDBG
2059
\section1 QMAKE_CXXFLAGS_MT_DLLDBG
2061
\c {This is used on Windows only.}
2063
This variable contains the C++ compiler flags for creating a multi-threaded debuggable
2064
dll. The value of this variable is typically handled by
2065
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2068
\target QMAKE_CXXFLAGS_RELEASE
2069
\section1 QMAKE_CXXFLAGS_RELEASE
2071
This variable contains the C++ compiler flags for creating an
2072
application. The value of this variable is typically handled by
2073
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2076
\target QMAKE_CXXFLAGS_SHLIB
2077
\section1 QMAKE_CXXFLAGS_SHLIB
2079
This variable contains the C++ compiler flags for creating a
2080
shared library. The value of this variable is typically handled by
2081
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2084
\target QMAKE_CXXFLAGS_THREAD
2085
\section1 QMAKE_CXXFLAGS_THREAD
2087
This variable contains the C++ compiler flags for creating a
2088
multi-threaded application. The value of this variable is typically handled by
2089
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs
2092
\target QMAKE_CXXFLAGS_WARN_OFF
2093
\section1 QMAKE_CXXFLAGS_WARN_OFF
2095
This variable contains the C++ compiler flags for suppressing compiler warnings.
2096
The value of this variable is typically handled by \c qmake or
2097
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2099
\target QMAKE_CXXFLAGS_WARN_ON
2100
\section1 QMAKE_CXXFLAGS_WARN_ON
2102
This variable contains C++ compiler flags for generating compiler warnings.
2103
The value of this variable is typically handled by \c qmake or
2104
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2106
\target QMAKE_DISTCLEAN
2107
\section1 QMAKE_DISTCLEAN
2109
This variable removes extra files upon the invocation of \c{make distclean}.
2111
\target QMAKE_EXTENSION_SHLIB
2112
\section1 QMAKE_EXTENSION_SHLIB
2114
This variable contains the extention for shared libraries. The value of this
2115
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf}
2116
and rarely needs to be modified.
2118
Note that platform-specific variables that change the extension will override
2119
the contents of this variable.
2121
\section1 QMAKE_EXT_MOC
2123
This variable changes the extention used on included moc files.
2125
See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
2127
\section1 QMAKE_EXT_UI
2129
This variable changes the extention used on /e Designer UI files.
2131
See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
2133
\section1 QMAKE_EXT_PRL
2135
This variable changes the extention used on created PRL files.
2137
See also \l{Configuring qmake's Environment#Extensions}{File Extensions},
2138
\l{Configuring qmake's Environment#libdepend}{Library Dependencies}.
2140
\section1 QMAKE_EXT_LEX
2142
This variable changes the extention used on files given to lex.
2144
See also \l{Configuring qmake's Environment#Extensions}{File Extensions},
2145
\l{#LEXSOURCES}{LEXSOURCES}.
2147
\section1 QMAKE_EXT_YACC
2148
This variable changes the extention used on files given to yacc.
2150
See also \l{Configuring qmake's Environment#Extensions}{File Extensions},
2151
\l{#YACCSOURCES}{YACCSOURCES}.
2153
\section1 QMAKE_EXT_OBJ
2155
This variable changes the extention used on generated object files.
2157
See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
2159
\section1 QMAKE_EXT_CPP
2161
This variable changes the interpretation of all suffixes in this
2162
list of values as files of type C++ source code.
2164
See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
2166
\section1 QMAKE_EXT_H
2168
This variable changes the interpretation of all suffixes in this
2169
list of values as files of type C header files.
2171
See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
2173
\section1 QMAKE_EXTRA_COMPILERS
2175
This variable contains the extra compilers/preprocessors that have been added
2177
See also \l{Configuring qmake's Environment#Customizing}{Customizing Makefile Output}
2179
\section1 QMAKE_EXTRA_TARGETS
2181
This variable contains the extra targets that have been added
2183
See also \l{Configuring qmake's Environment#Customizing}{Customizing Makefile Output}
2185
\target QMAKE_FAILED_REQUIREMENTS
2186
\section1 QMAKE_FAILED_REQUIREMENTS
2188
This variable contains the list of requirements that were failed to be met when
2189
\c qmake was used. For example, the sql module is needed and wasn't compiled into Qt. The
2190
value of this variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf}
2191
and rarely needs to be modified.
2193
\target QMAKE_FILETAGS
2194
\section1 QMAKE_FILETAGS
2196
This variable contains the file tags needed to be entered into the Makefile, such as SOURCES
2197
and HEADERS. The value of this variable is typically handled by \c qmake or
2198
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2200
\section1 QMAKE_FRAMEWORK_BUNDLE_NAME
2202
In a framework project, this variable contains the name to be used for the
2203
framework that is built.
2205
By default, this variable contains the same value as the \l{#TARGET}{TARGET}
2208
See \l{qmake Platform Notes#Creating Frameworks}{qmake Platform Notes} for
2209
more information about creating frameworks and library bundles.
2211
\e{This is used on Mac OS X only.}
2213
\target QMAKE_FRAMEWORK_VERSION
2214
\section1 QMAKE_FRAMEWORK_VERSION
2216
For projects where the build target is a Mac OS X framework, this variable
2217
is used to specify the version number that will be applied to the framework
2220
By default, this variable contains the same value as the \l{#VERSION}{VERSION}
2223
See \l{qmake Platform Notes#Creating Frameworks}{qmake Platform Notes} for
2224
more information about creating frameworks.
2226
\e{This is used on Mac OS X only.}
2228
\target QMAKE_INCDIR
2229
\section1 QMAKE_INCDIR
2231
This variable contains the location of all known header files to be added to
2232
INCLUDEPATH when building an application. The value of this variable is
2233
typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
2234
needs to be modified.
2236
\target QMAKE_INCDIR_EGL
2237
\section1 QMAKE_INCDIR_EGL
2239
This variable contains the location of EGL header files to be added
2240
to INCLUDEPATH when building an application with OpenGL/ES or
2241
OpenVG support. The value of this variable is typically handled by
2242
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2244
\target QMAKE_INCDIR_OPENGL
2245
\section1 QMAKE_INCDIR_OPENGL
2247
This variable contains the location of OpenGL header files to be added
2248
to INCLUDEPATH when building an application with OpenGL support. The
2249
value of this variable is typically handled by \c qmake or
2250
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2252
If the OpenGL implementation uses EGL (most OpenGL/ES systems),
2253
then QMAKE_INCDIR_EGL may also need to be set.
2255
\target QMAKE_INCDIR_OPENVG
2256
\section1 QMAKE_INCDIR_OPENVG
2258
This variable contains the location of OpenVG header files to be added
2259
to INCLUDEPATH when building an application with OpenVG support. The
2260
value of this variable is typically handled by \c qmake or
2261
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2263
If the OpenVG implementation uses EGL then QMAKE_INCDIR_EGL may also
2266
\target QMAKE_INCDIR_QT
2267
\section1 QMAKE_INCDIR_QT
2269
This variable contains the location of all known header file
2270
paths to be added to INCLUDEPATH when building a Qt application. The value
2271
of this variable is typically handled by \c qmake or
2272
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2274
\target QMAKE_INCDIR_THREAD
2275
\section1 QMAKE_INCDIR_THREAD
2277
This variable contains the location of all known header file
2278
paths to be added to INCLUDEPATH when building a multi-threaded application.
2279
The value of this variable is typically handled by \c qmake or
2280
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2282
\target QMAKE_INCDIR_X11
2283
\section1 QMAKE_INCDIR_X11
2285
\e {This is used on Unix platforms only.}
2287
This variable contains the location of X11 header file paths to be
2288
added to INCLUDEPATH when building a X11 application. The
2289
value of this variable is typically handled by \c qmake or
2290
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2292
\target QMAKE_INFO_PLIST
2293
\section1 QMAKE_INFO_PLIST
2295
\e {This is used on Mac OS X platforms only.}
2297
This variable contains the name of the property list file, \c{.plist}, you
2298
would like to include in your Mac OS X application bundle.
2300
In the \c{.plist} file, you can define some variables, e.g., @EXECUTABLE@,
2301
which qmake will replace with the actual executable name. Other variables
2302
include @ICON@, @TYPEINFO@, @LIBRARY@, and @SHORT_VERSION@.
2304
\note Most of the time, the default \c{Info.plist} is good enough.
2306
\section1 QMAKE_LFLAGS
2308
This variable contains a general set of flags that are passed to
2309
the linker. If you need to change the flags used for a particular
2310
platform or type of project, use one of the specialized variables
2311
for that purpose instead of this variable.
2313
\target QMAKE_LFLAGS_CONSOLE
2314
\section1 QMAKE_LFLAGS_CONSOLE
2316
\e {This is used on Windows only.}
2318
This variable contains link flags when building console
2319
programs. The value of this variable is typically handled by
2321
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2323
\section1 QMAKE_LFLAGS_CONSOLE_DLL
2325
\e {This is used on Windows only.}
2327
This variable contains link flags when building console
2328
dlls. The value of this variable is typically handled by
2330
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2332
\section1 QMAKE_LFLAGS_DEBUG
2334
This variable contains link flags when building debuggable applications. The
2335
value of this variable is typically handled by \c qmake or
2336
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2338
\section1 QMAKE_LFLAGS_PLUGIN
2340
This variable contains link flags when building plugins. The value
2341
of this variable is typically handled by \c qmake or
2342
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2344
\section1 QMAKE_LFLAGS_QT_DLL
2346
This variable contains link flags when building programs that
2347
use the Qt library built as a dll. The value of this variable is
2348
typically handled by \c qmake or
2349
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2351
\section1 QMAKE_LFLAGS_RELEASE
2353
This variable contains link flags when building applications for
2354
release. The value of this variable is typically handled by
2355
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2357
\section1 QMAKE_LFLAGS_SHAPP
2359
This variable contains link flags when building applications which are using
2360
the \c app template. The value of this variable is typically handled by
2361
\c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2363
\section1 QMAKE_LFLAGS_SHLIB
2365
This variable contains link flags when building shared libraries
2366
The value of this variable is typically handled by \c qmake or
2367
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2369
\section1 QMAKE_LFLAGS_SONAME
2371
This variable specifies the link flags to set the name of shared objects,
2372
such as .so or .dll. The value of this variable is typically handled by \c
2373
qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2375
\section1 QMAKE_LFLAGS_THREAD
2377
This variable contains link flags when building multi-threaded projects.
2378
The value of this variable is typically handled by \c qmake or
2379
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2381
\section1 QMAKE_LFLAGS_WINDOWS
2383
\e {This is used on Windows only.}
2385
This variable contains link flags when building Windows GUI projects
2386
(i.e. non-console applications).
2387
The value of this variable is typically handled by \c qmake or
2388
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2390
\section1 QMAKE_LFLAGS_WINDOWS_DLL
2392
\e {This is used on Windows only.}
2394
This variable contains link flags when building Windows DLL projects.
2395
The value of this variable is typically handled by \c qmake or
2396
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2398
\section1 QMAKE_LIBDIR
2400
This variable contains the location of all known library
2401
directories.The value of this variable is typically handled by
2403
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2405
\section1 QMAKE_LIBDIR_FLAGS
2407
\e {This is used on Unix platforms only.}
2409
This variable contains the location of all library
2410
directory with -L prefixed. The value of this variable is typically handled by
2412
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2414
\section1 QMAKE_LIBDIR_EGL
2416
This variable contains the location of the EGL library
2417
directory, when EGL is used with OpenGL/ES or OpenVG. The value
2418
of this variable is typically handled by \c qmake or
2419
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2421
\section1 QMAKE_LIBDIR_OPENGL
2423
This variable contains the location of the OpenGL library
2424
directory.The value of this variable is typically handled by
2426
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2428
If the OpenGL implementation uses EGL (most OpenGL/ES systems),
2429
then QMAKE_LIBDIR_EGL may also need to be set.
2431
\section1 QMAKE_LIBDIR_OPENVG
2433
This variable contains the location of the OpenVG library
2434
directory. The value of this variable is typically handled by
2436
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2438
If the OpenVG implementation uses EGL, then QMAKE_LIBDIR_EGL
2439
may also need to be set.
2441
\section1 QMAKE_LIBDIR_QT
2443
This variable contains the location of the Qt library
2444
directory.The value of this variable is typically handled by
2446
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2448
\section1 QMAKE_LIBDIR_X11
2450
\e {This is used on Unix platforms only.}
2452
This variable contains the location of the X11 library
2453
directory.The value of this variable is typically handled by
2455
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2457
\section1 QMAKE_LIBS
2459
This variable contains all project libraries. The value of this
2460
variable is typically handled by \c qmake or
2461
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2463
\section1 QMAKE_LIBS_CONSOLE
2465
\e {This Windows-specific variable is no longer used.}
2467
Prior to Qt 4.2, this variable was used to list the libraries
2468
that should be linked against when building a console application
2469
project on Windows. \l{#QMAKE_LIBS_WINDOW}{QMAKE_LIBS_WINDOW}
2470
should now be used instead.
2472
\section1 QMAKE_LIBS_EGL
2474
This variable contains all EGL libraries when building Qt with
2475
OpenGL/ES or OpenVG. The value of this variable is typically
2476
handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
2477
needs to be modified. The usual value is \c{-lEGL}.
2479
\section1 QMAKE_LIBS_OPENGL
2481
This variable contains all OpenGL libraries. The value of this
2482
variable is typically handled by \c qmake or
2483
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2485
If the OpenGL implementation uses EGL (most OpenGL/ES systems),
2486
then QMAKE_LIBS_EGL may also need to be set.
2488
\section1 QMAKE_LIBS_OPENGL_QT
2490
This variable contains all OpenGL Qt libraries.The value of this
2491
variable is typically handled by \c qmake or
2492
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2494
\section1 QMAKE_LIBS_OPENVG
2496
This variable contains all OpenVG libraries. The value of this
2497
variable is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf}
2498
and rarely needs to be modified. The usual value is \c{-lOpenVG}.
2500
Some OpenVG engines are implemented on top of OpenGL. This will
2501
be detected at configure time and QMAKE_LIBS_OPENGL will be implicitly
2502
added to QMAKE_LIBS_OPENVG wherever the OpenVG libraries are linked.
2504
If the OpenVG implementation uses EGL, then QMAKE_LIBS_EGL may also
2507
\section1 QMAKE_LIBS_QT
2509
This variable contains all Qt libraries.The value of this
2510
variable is typically handled by \c qmake or
2511
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2513
\section1 QMAKE_LIBS_QT_DLL
2515
\e {This is used on Windows only.}
2517
This variable contains all Qt libraries when Qt is built as a dll. The
2518
value of this variable is typically handled by \c qmake or
2519
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2521
\section1 QMAKE_LIBS_QT_OPENGL
2523
This variable contains all the libraries needed to link against if
2524
OpenGL support is turned on. The
2525
value of this variable is typically handled by \c qmake or
2526
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2528
\section1 QMAKE_LIBS_QT_THREAD
2530
This variable contains all the libraries needed to link against if
2531
thread support is turned on. The
2532
value of this variable is typically handled by \c qmake or
2533
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2535
\section1 QMAKE_LIBS_RT
2537
\e {This is used with Borland compilers only.}
2539
This variable contains the runtime library needed to link against when
2540
building an application. The
2541
value of this variable is typically handled by \c qmake or
2542
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2544
\section1 QMAKE_LIBS_RTMT
2546
\e {This is used with Borland compilers only.}
2548
This variable contains the runtime library needed to link against when
2549
building a multi-threaded application. The
2550
value of this variable is typically handled by \c qmake or
2551
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2553
\section1 QMAKE_LIBS_THREAD
2555
\e {This is used on Unix platforms only.}
2557
This variable contains all libraries that need to be linked against
2558
when building a multi-threaded application. The
2559
value of this variable is typically handled by \c qmake or
2560
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2562
\section1 QMAKE_LIBS_WINDOWS
2564
\e {This is used on Windows only.}
2566
This variable contains all windows libraries.The value of this
2567
variable is typically handled by \c qmake or
2568
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2570
\section1 QMAKE_LIBS_X11
2572
\e {This is used on Unix platforms only.}
2574
This variable contains all X11 libraries.The value of this
2575
variable is typically handled by \c qmake or
2576
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2578
\section1 QMAKE_LIBS_X11SM
2580
\e {This is used on Unix platforms only.}
2582
This variable contains all X11 session management libraries. The
2583
value of this variable is typically handled by \c qmake or
2584
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2586
\section1 QMAKE_LIB_FLAG
2588
This variable is not empty if the \c lib template is specified. The
2589
value of this variable is typically handled by \c qmake or
2590
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2592
\section1 QMAKE_LINK_SHLIB_CMD
2594
This variable contains the command to execute when creating a
2596
value of this variable is typically handled by \c qmake or
2597
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2599
\section1 QMAKE_POST_LINK
2601
This variable contains the command to execute after linking the TARGET
2602
together. This variable is normally empty and therefore nothing is
2603
executed, additionally some backends will not support this - mostly only
2606
\section1 QMAKE_PRE_LINK
2608
This variable contains the command to execute before linking the TARGET
2609
together. This variable is normally empty and therefore nothing is
2610
executed, additionally some backends will not support this - mostly only
2613
\section1 QMAKE_LN_SHLIB
2615
This variable contains the command to execute when creating a link
2616
to a shared library. The
2617
value of this variable is typically handled by \c qmake or
2618
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2620
\section1 QMAKE_MAC_SDK
2622
This variable is used on Mac OS X when building universal binaries.
2623
This process is described in more detail in the
2624
\l{Deploying an Application on Mac OS X#Architecture Dependencies}{Deploying
2625
an Application on Mac OS X} document.
2627
\section1 QMAKE_MACOSX_DEPLOYMENT_TARGET
2628
This variable only has an effect when building on Mac OS X. On that
2629
platform, the variable will be forwarded to the MACOSX_DEPLOYMENT_TARGET
2630
environment variable, which is interpreted by the compiler or linker.
2631
For more information, see the
2632
\l{Deploying an Application on Mac OS X#Mac OS X Version Dependencies}{Deploying
2633
an Application on Mac OS X} document.
2635
\section1 QMAKE_MAKEFILE
2637
This variable contains the name of the Makefile to create. The
2638
value of this variable is typically handled by \c qmake or
2639
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2641
\section1 QMAKE_MOC_SRC
2643
This variable contains the names of all moc source files to
2644
generate and include in the project. The value of this variable is
2645
typically handled by \c qmake or
2646
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2648
\section1 QMAKE_QMAKE
2650
This variable contains the location of qmake if it is not in the path.
2651
The value of this variable is typically handled by \c qmake or
2652
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2654
\section1 QMAKE_QT_DLL
2656
This variable is not empty if Qt was built as a dll. The
2657
value of this variable is typically handled by \c qmake or
2658
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2660
\section1 QMAKE_RESOURCE_FLAGS
2662
This variable is used to customize the list of options passed to the
2663
\l{rcc}{Resource Compiler} in each of the build rules where it is used.
2664
For example, the following line ensures that the \c{-threshold} and
2665
\c{-compress} options are used with particular values each time that
2668
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 45
2670
\section1 QMAKE_RUN_CC
2672
This variable specifies the individual rule needed to build an object.
2673
The value of this variable is typically handled by \c qmake or
2674
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2676
\section1 QMAKE_RUN_CC_IMP
2678
This variable specifies the individual rule needed to build an object.
2679
The value of this variable is typically handled by \c qmake or
2680
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2682
\section1 QMAKE_RUN_CXX
2684
This variable specifies the individual rule needed to build an object.
2685
The value of this variable is typically handled by \c qmake or
2686
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2688
\section1 QMAKE_RUN_CXX_IMP
2690
This variable specifies the individual rule needed to build an object.
2691
The value of this variable is typically handled by \c qmake or
2692
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2694
\section1 QMAKE_TARGET
2696
This variable contains the name of the project target. The value of
2697
this variable is typically handled by \c qmake or
2698
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2702
This variable contains the location of uic if it is not in the path.
2703
The value of this variable is typically handled by \c qmake or
2704
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2706
It can be used to specify arguments to uic as well, such as additional plugin
2709
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 46
2713
The values stored in the \c QT variable control which of the Qt modules are
2714
used by your project.
2716
The table below shows the options that can be used with the \c QT variable
2717
and the features that are associated with each of them:
2720
\header \o Option \o Features
2721
\row \o core (included by default) \o QtCore module
2722
\row \o gui (included by default) \o QtGui module
2723
\row \o network \o QtNetwork module
2724
\row \o opengl \o QtOpenGL module
2725
\row \o phonon \o Phonon Multimedia Framework
2726
\row \o sql \o QtSql module
2727
\row \o svg \o QtSvg module
2728
\row \o xml \o QtXml module
2729
\row \o webkit \o WebKit integration
2730
\row \o qt3support \o Qt3Support module
2733
By default, \c QT contains both \c core and \c gui, ensuring that standard
2734
GUI applications can be built without further configuration.
2736
If you want to build a project \e without the QtGui module, you need to
2737
exclude the \c gui value with the "-=" operator; the following line will
2738
result in a minimal Qt project being built:
2740
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 47
2742
Note that adding the \c opengl option to the \c QT variable automatically
2743
causes the equivalent option to be added to the \c CONFIG variable.
2744
Therefore, for Qt applications, it is not necessary to add the \c opengl
2745
option to both \c CONFIG and \c{QT}.
2749
This variable contains a list of names of static plugins that are to be
2750
compiled with an application so that they are available as built-in
2754
\section1 QT_VERSION
2756
This variable contains the current version of Qt.
2758
\target QT_MAJOR_VERSION
2759
\section1 QT_MAJOR_VERSION
2761
This variable contains the current major version of Qt.
2763
\target QT_MINOR_VERSION
2764
\section1 QT_MINOR_VERSION
2766
This variable contains the current minor version of Qt.
2768
\target QT_PATCH_VERSION
2769
\section1 QT_PATCH_VERSION
2771
This variable contains the current patch version of Qt.
2775
This variable contains the name of the resource file for the application.
2776
The value of this variable is typically handled by \c qmake or
2777
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2782
This variable specifies the directory where all intermediate
2783
resource files should be placed.
2787
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 48
2792
This is a special variable processed by \c qmake. If the
2793
contents of this variable do not appear in CONFIG by the time this
2794
variable is assigned, then a minimal Makefile will be generated that
2795
states what dependencies (the values assigned to REQUIRES) are
2798
This is mainly used in Qt's build system for building the examples.
2802
This variable contains the name of the resource collection file (qrc)
2803
for the application. Further information about the resource collection
2804
file can be found at \l{The Qt Resource System}.
2808
This variable contains the name of the resource file for the application.
2809
The value of this variable is typically handled by \c qmake or
2810
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
2815
\e {This is only used on the Symbian platform.}
2817
Generic RSS file content can be specified with this variable. The syntax is
2818
similar to \c MMP_RULES and \c BLD_INF_RULES.
2822
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 144
2824
This will add the specified statement to the end of the generated
2825
registration resource file. As an impact of this statement, the application
2826
will not be visible in application shell.
2828
It is also possible to add multiple rows in a single block. Each double
2829
quoted string will be placed on a new row in the registration resource file.
2833
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 145
2835
This example will install the application to MyFolder in the Symbian
2836
platform application shell. In addition it will make the application to
2837
be launched in background.
2839
For detailed list of possible RSS statements, please refer to the
2840
Symbian platform help.
2842
\note You should not use \c RSS_RULES variable to set the following RSS statements:
2845
localisable_resource_file
2846
localisable_resource_id
2848
These statements are internally handled by qmake.
2851
\section1 S60_VERSION
2853
\e {This is only used on the Symbian platform.}
2855
Contains the version number of the underlying S60 SDK; e.g. "5.0".
2857
\target SIGNATURE_FILE
2858
\section1 SIGNATURE_FILE
2860
\e {This is only used on Windows CE.}
2862
Specifies which signature file should be used to sign the project target.
2864
\note This variable will overwrite the setting you have specified in configure,
2865
with the \c -signature option.
2870
This variable contains the name of all source files in the project.
2874
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 49
2876
See also \l{#HEADERS}{HEADERS}
2880
This variable is set by \c qmake if files can be found that
2881
contain the Q_OBJECT macro. \c SRCMOC contains the
2882
name of all the generated moc files. The value of this variable
2883
is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
2889
This variable, when used with the \l{#TEMPLATE}{\c subdirs template}
2890
contains the names of all subdirectories that contain parts of the project
2891
that need be built. Each subdirectory must contain its own project file.
2895
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 50
2897
It is essential that the project file in each subdirectory has the same
2898
name as the subdirectory itself, so that \c qmake can find it.
2899
For example, if the subdirectory is called \c myapp then the project file
2900
in that directory should be called \c myapp.pro.
2902
If you need to ensure that the subdirectories are built in the order in
2903
which they are specified, update the \l{#CONFIG}{CONFIG} variable to
2904
include the \c ordered option:
2906
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 51
2911
This specifies the name of the target file.
2915
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 52
2917
The project file above would produce an executable named \c myapp on
2918
unix and 'myapp.exe' on windows.
2920
\target TARGET.CAPABILITY
2921
\section1 TARGET.CAPABILITY
2923
\e {This is only used on the Symbian platform.}
2925
Specifies which platform capabilities the application should have. For more
2926
information, please refer to the Symbian SDK documentation.
2928
\target TARGET.EPOCALLOWDLLDATA
2929
\section1 TARGET.EPOCALLOWDLLDATA
2931
\e {This is only used on the Symbian platform.}
2933
Specifies whether static data should be allowed in the application. Symbian
2934
disallows this by default in order to save memory. To use it, set this to 1.
2936
\target TARGET.EPOCHEAPSIZE
2937
\section1 TARGET.EPOCHEAPSIZE
2939
\e {This is only used on the Symbian platform.}
2941
Specifies the minimum and maximum heap size of the application. The program
2942
will refuse to run if the minimum size is not available when it starts. For
2945
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 135
2947
\target TARGET.EPOCSTACKSIZE
2948
\section1 TARGET.EPOCSTACKSIZE
2950
\e {This is only used on the Symbian platform.}
2952
Specifies the maximum stack size of the application. For example:
2954
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 136
2957
\section1 TARGET.SID
2959
\e {This is only used on the Symbian platform.}
2961
Specifies which secure identifier to use for the target application or
2962
library. For more information, see the Symbian SDK documentation.
2965
\section1 TARGET.UID2
2967
\e {This is only used on the Symbian platform.}
2969
Specifies which unique identifier 2 to use for the target application or
2970
library. If this variable is not specified, it defaults to the same value
2971
as TARGET.UID3. For more information, see the Symbian SDK documentation.
2974
\section1 TARGET.UID3
2976
\e {This is only used on the Symbian platform.}
2978
Specifies which unique identifier 3 to use for the target application or
2979
library. If this variable is not specified, a UID3 suitable for development
2980
and debugging will be generated automatically. However, applications being
2981
released should always define this variable. For more information, see the
2982
Symbian SDK documentation.
2985
\section1 TARGET.VID
2987
\e {This is only used on the Symbian platform.}
2989
Specifies which vendor identifier to use for the target application or
2990
library. For more information, see the Symbian SDK documentation.
2992
\section1 TARGET_EXT
2994
This variable specifies the target's extension. The value of this variable
2995
is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
3000
This variable specifies the target's extension with a major version number. The value of this variable
3001
is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
3004
\section1 TARGET_x.y.z
3006
This variable specifies the target's extension with version number. The value of this variable
3007
is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
3013
This variable contains the name of the template to use when
3014
generating the project. The allowed values are:
3017
\header \o Option \o Description
3018
\row \o app \o Creates a Makefile for building applications (the default). (See
3019
\l{qmake Common Projects#Application}{qmake Common Projects} for more information.)
3020
\row \o lib \o Creates a Makefile for building libraries. (See
3021
\l{qmake Common Projects#Library}{qmake Common Projects} for more information.)
3022
\row \o subdirs \o Creates a Makefile for building targets in subdirectories.
3023
The subdirectories are specified using the \l{#SUBDIRS}{SUBDIRS}
3025
\row \o vcapp \o \e {Windows only} Creates an application project for Visual Studio.
3026
(See \l{qmake Platform Notes#Creating Visual Studio Project Files}{qmake Platform Notes}
3027
for more information.)
3028
\row \o vclib \o \e {Windows only} Creates a library project for Visual Studio.
3029
(See \l{qmake Platform Notes#Creating Visual Studio Project Files}{qmake Platform Notes}
3030
for more information.)
3035
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 53
3037
The template can be overridden by specifying a new template type with the
3038
\c -t command line option. This overrides the template type \e after the .pro
3039
file has been processed. With .pro files that use the template type to
3040
determine how the project is built, it is necessary to declare TEMPLATE on
3041
the command line rather than use the \c -t option.
3043
\section1 TRANSLATIONS
3045
This variable contains a list of translation (.ts) files that contain
3046
translations of the user interface text into non-native languages.
3048
See the \l{Qt Linguist Manual} for more information about
3049
internationalization (i18n) and localization (l10n) with Qt.
3053
This variable contains a list of the generated implementation files by UIC.
3054
The value of this variable
3055
is typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be
3058
\section1 UICOBJECTS
3060
This variable is generated from the UICIMPLS variable. The extension of each
3061
file will have been replaced by .o (Unix) or .obj (Win32). The value of this variable is
3062
typically handled by \c qmake or \l{#QMAKESPEC}{qmake.conf} and
3063
rarely needs to be modified.
3068
This variable specifies the directory where all intermediate files from uic
3069
should be placed. This variable overrides both UI_SOURCES_DIR and
3074
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 54
3076
\target UI_HEADERS_DIR
3077
\section1 UI_HEADERS_DIR
3079
This variable specifies the directory where all declaration files (as
3080
generated by uic) should be placed.
3084
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 55
3086
\target UI_SOURCES_DIR
3087
\section1 UI_SOURCES_DIR
3089
This variable specifies the directory where all implementation files (as generated
3090
by uic) should be placed.
3094
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 56
3099
This variable contains the version number of the application or library if
3100
either the \c app \l{#TEMPLATE}{TEMPLATE} or the \c lib \l{#TEMPLATE}{TEMPLATE}
3105
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 57
3109
This variable contains the major version number of the library, if the
3110
\c lib \l{#TEMPLATE}{template} is specified.
3114
This variable contains the minor version number of the library, if the
3115
\c lib \l{#TEMPLATE}{template} is specified.
3119
This variable contains the patch version number of the library, if the
3120
\c lib \l{#TEMPLATE}{template} is specified.
3124
This variable tells \c qmake where to search for files it cannot
3125
open. With this you may tell \c qmake where it may look for things
3126
like SOURCES, and if it finds an entry in SOURCES that cannot be
3127
opened it will look through the entire VPATH list to see if it can
3128
find the file on its own.
3130
See also \l{#DEPENDPATH}{DEPENDPATH}.
3134
This variable contains a list of yacc source files. The value of
3135
this variable is typically handled by \c qmake or
3136
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
3138
\section1 YACCOBJECTS
3140
This variable contains a list of yacc object files. The value of
3141
this variable is typically handled by \c qmake or
3142
\l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
3145
\section1 YACCSOURCES
3147
This variable contains a list of yacc source files to be included
3148
in the project. All dependencies, headers and source files will
3149
automatically be included in the project.
3153
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 58
3155
\section1 _PRO_FILE_
3157
This variable contains the path to the project file in use.
3159
For example, the following line causes the location of the project
3160
file to be written to the console:
3162
\snippet doc/src/snippets/qmake/project_location.pro project file
3164
\section1 _PRO_FILE_PWD_
3166
This variable contains the path to the directory containing the project
3169
For example, the following line causes the location of the directory
3170
containing the project file to be written to the console:
3172
\snippet doc/src/snippets/qmake/project_location.pro project file directory
3176
\page qmake-function-reference.html
3177
\title qmake Function Reference
3178
\contentspage {qmake Manual}{Contents}
3179
\previouspage qmake Variable Reference
3180
\nextpage Configuring qmake's Environment
3182
\c qmake provides built-in functions to allow the contents of
3183
variables to be processed, and to enable tests to be performed
3184
during the configuration process. Functions that process the
3185
contents of variables typically return values that can be assigned
3186
to other variables, and these values are obtained by prefixing
3187
function with the \c $$ operator. Functions that perform tests
3188
are usually used as the conditional parts of scopes; these are
3189
indicated in the function descriptions below.
3193
\section1 basename(variablename)
3195
Returns the basename of the file specified. For example:
3197
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 59
3199
\section1 CONFIG(config)
3202
This function can be used to test for variables placed into the
3203
\c CONFIG variable. This is the same as regular old style (tmake) scopes,
3204
but has the added advantage a second parameter can be passed to test for
3205
the active config. As the order of values is important in \c CONFIG
3206
variables (i.e. the last one set will be considered the active config for
3207
mutually exclusive values) a second parameter can be used to specify a set
3208
of values to consider. For example:
3210
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 60
3212
Because release is considered the active setting (for feature parsing)
3213
it will be the CONFIG used to generate the build file. In the common
3214
case a second parameter is not needed, but for specific mutual
3215
exclusive tests it is invaluable.
3217
\section1 contains(variablename, value)
3220
Succeeds if the variable \e variablename contains the value \e value;
3221
otherwise fails. You can check the return value of this function using
3226
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 61
3228
The contents of the scope are only processed if the \c drivers
3229
variable contains the value, \c network. If this is the case, the
3230
appropriate files are added to the \c SOURCES and \c HEADERS
3233
\section1 count(variablename, number)
3236
Succeeds if the variable \e variablename contains a list with the
3237
specified \e number of value; otherwise fails.
3239
This function is used to ensure that declarations inside a scope are
3240
only processed if the variable contains the correct number of values;
3243
\snippet doc/src/snippets/qmake/functions.pro 2
3245
\section1 dirname(file)
3247
Returns the directory name part of the specified file. For example:
3249
\snippet doc/src/snippets/qmake/dirname.pro 0
3251
\section1 error(string)
3253
This function never returns a value. \c qmake displays the given
3254
\e string to the user, and exits. This function should only be used
3255
for unrecoverable errors.
3259
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 62
3261
\section1 eval(string)
3264
Evaluates the contents of the string using \c qmake's syntax rules
3266
Definitions and assignments can be used in the string to modify the
3267
values of existing variables or create new definitions.
3270
\snippet doc/src/snippets/qmake/functions.pro 4
3272
Note that quotation marks can be used to delimit the string, and that
3273
the return value can be discarded if it is not needed.
3275
\section1 exists(filename)
3278
Tests whether a file with the given \e filename exists.
3279
If the file exists, the function succeeds; otherwise it fails.
3280
If a regular expression is specified for the filename, this function
3281
succeeds if any file matches the regular expression specified.
3284
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 63
3286
Note that "/" can be used as a directory separator, regardless of the
3289
\section1 find(variablename, substr)
3291
Places all the values in \e variablename that match \e substr. \e
3292
substr may be a regular expression, and will be matched accordingly.
3294
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 64
3296
MY_VAR2 will contain '-Lone -Ltwo -Lthree -Lfour -Lfive', and MY_VAR3 will
3297
contains 'three two three'.
3299
\section1 for(iterate, list)
3301
This special test function will cause a loop to be started that
3302
iterates over all values in \e list, setting \e iterate to each
3303
value in turn. As a convenience, if \e list is 1..10 then iterate will
3304
iterate over the values 1 through 10.
3306
The use of an else scope afer a condition line with a for() loop is
3311
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 65
3313
\section1 include(filename)
3316
Includes the contents of the file specified by \e filename into the
3317
current project at the point where it is included. This function
3318
succeeds if \e filename is included; otherwise it fails. The included
3319
file is processed immediately.
3321
You can check whether the file was included by using this function as
3322
the condition for a scope; for example:
3324
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 66
3326
\section1 infile(filename, var, val)
3329
Succeeds if the file \e filename (when parsed by \c qmake itself)
3330
contains the variable \e var with a value of \e val; otherwise fails.
3331
If you do not specify a third argument (\e val), the function will
3332
only test whether \e var has been declared in the file.
3334
\section1 isEmpty(variablename)
3337
Succeeds if the variable \e variablename is empty; otherwise fails.
3338
This is the equivalent of \c{count( variablename, 0 )}.
3342
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 67
3344
\section1 join(variablename, glue, before, after)
3346
Joins the value of \e variablename with \c glue. If this value is
3347
non-empty it prefixes the value with \e before and suffix it with \e
3348
after. \e variablename is the only required field, the others default
3349
to empty strings. If you need to encode spaces in \e glue, \e before, or \e
3350
after you must quote them.
3352
\section1 member(variablename, position)
3354
Returns the value at the given \e position in the list of items in
3356
If an item cannot be found at the position specified, an empty string is
3357
returned. \e variablename is the only required field. If not specified,
3358
\c position defaults to 0, causing the first value in the list to be
3361
\section1 message(string)
3363
This function simply writes a message to the console. Unlike the
3364
\c error() function, this function allows processing to continue.
3366
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 68
3368
The above line causes "This is a message" to be written to the console.
3369
The use of quotation marks is optional.
3371
\note By default, messages are written out for each Makefile generated by
3372
qmake for a given project. If you want to ensure that messages only appear
3373
once for each project, test the \c build_pass variable
3374
\l{qmake Advanced Usage}{in conjunction with a scope} to filter out
3375
messages during builds; for example:
3377
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 69
3379
\section1 prompt(question)
3381
Displays the specified \e question, and returns a value read from stdin.
3383
\section1 quote(string)
3385
Converts a whole \e string into a single entity and returns the result.
3386
Newlines, carriage returns, and tabs can be specified in the string
3387
with \\n \\r and \\t. The return value does not contain either single
3388
or double quotation marks unless you explicitly include them yourself,
3389
but will be placed into a single entry (for literal expansion).
3391
\section1 replace(string, old_string, new_string)
3393
Replaces each instance of \c old_string with \c new_string in the
3394
contents of the variable supplied as \c string. For example, the
3397
\snippet doc/src/snippets/qmake/replace.pro 0
3401
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 70
3403
\section1 sprintf(string, arguments...)
3405
Replaces %1-%9 with the arguments passed in the comma-separated list
3406
of function \e arguments and returns the processed string.
3408
\section1 system(command)
3411
Executes the given \c command in a secondary shell, and succeeds
3412
if the command returns with a zero exit status; otherwise fails.
3413
You can check the return value of this function using a scope:
3417
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 71
3419
Alternatively, you can use this function to obtain stdout and stderr
3420
from the command, and assign it to a variable. For example, you can
3421
use this to interrogate information about the platform:
3423
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 72
3426
\section1 unique(variablename)
3428
This will return a list of values in variable that are unique (that is
3429
with repetitive entries removed). For example:
3431
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 73
3433
\section1 warning(string)
3435
This function will always succeed, and will display the given
3436
\e string to the user. message() is a synonym for warning().
3440
\page qmake-environment-reference.html
3441
\contentspage {qmake Manual}{Contents}
3442
\previouspage qmake Function Reference
3444
\title Configuring qmake's Environment
3449
\section1 Properties
3451
\c qmake has a system of persistant information, this allows you to
3452
\c set a variable in qmake once, and each time qmake is invoked this
3453
value can be queried. Use the following to set a property in qmake:
3455
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 74
3457
The appropriate variable and value should be substituted for
3458
\c VARIABLE and \c VALUE.
3460
To retrieve this information back from qmake you can do:
3462
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 75
3464
\note \c{qmake -query} will only list variables that you have
3465
previously set with \c{qmake -set VARIABLE VALUE}.
3467
This information will be saved into a QSettings object (meaning it
3468
will be stored in different places for different platforms). As
3469
\c VARIABLE is versioned as well, you can set one value in an older
3470
version of \c qmake, and newer versions will retrieve this value. However,
3471
if you set \c VARIABLE for a newer version of \c qmake, the older version
3472
will not use this value. You can however query a specific version of a
3473
variable if you prefix that version of \c qmake to \c VARIABLE, as in
3474
the following example:
3476
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 76
3478
\c qmake also has the notion of \c builtin properties, for example you can
3479
query the installation of Qt for this version of \c qmake with the
3480
\c QT_INSTALL_PREFIX property:
3482
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 77
3484
These built-in properties cannot have a version prefixed to them as
3485
they are not versioned, and each version of \c qmake will have its own
3486
built-in set of these values. The list below outlines the built-in
3490
\o \c QT_INSTALL_PREFIX - Where the version of Qt this qmake is built for resides
3491
\o \c QT_INSTALL_DATA - Where data for this version of Qt resides
3492
\o \c QMAKE_VERSION - The current version of qmake
3495
Finally, these values can be queried in a project file with a special
3498
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 78
3503
\c qmake requires a platform and compiler description file which
3504
contains many default values used to generate appropriate Makefiles.
3505
The standard Qt distribution comes with many of these files, located
3506
in the \c mkspecs subdirectory of the Qt installation.
3508
The \c QMAKESPEC environment variable can contain any of the following:
3511
\o A complete path to a directory containing a \c{qmake.conf} file.
3512
In this case \c qmake will open the \c{qmake.conf} file from within that
3513
directory. If the file does not exist, \c qmake will exit with an
3515
\o The name of a platform-compiler combination. In this case, \c qmake
3516
will search in the directory specified by the \c mkspecs subdirectory
3517
of the data path specified when Qt was compiled (see
3518
QLibraryInfo::DataPath).
3521
\bold{Note:} The \c QMAKESPEC path will automatically be added to the
3522
\l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH} system variable.
3527
It is common on Unix to also use the build tool to install applications
3528
and libraries; for example, by invoking \c{make install}. For this reason,
3529
\c qmake has the concept of an install set, an object which contains
3530
instructions about the way part of a project is to be installed.
3531
For example, a collection of documentation files can be described in the
3534
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 79
3536
The \c path member informs \c qmake that the files should be installed in
3537
\c /usr/local/program/doc (the path member), and the \c files member
3538
specifies the files that should be copied to the installation directory.
3539
In this case, everything in the \c docs directory will be coped to
3540
\c /usr/local/program/doc.
3542
Once an install set has been fully described, you can append it to the
3543
install list with a line like this:
3545
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 80
3547
\c qmake will ensure that the specified files are copied to the installation
3548
directory. If you require greater control over this process, you can also
3549
provide a definition for the \c extra member of the object. For example,
3550
the following line tells \c qmake to execute a series of commands for this
3553
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 81
3556
(see \l{qmake Advanced Usage#Scopes and Conditions}{Scopes and Conditions})
3557
ensures that these particular commands are only executed on Unix platforms.
3558
Appropriate commands for other platforms can be defined using other scope
3561
Commands specified in the \c extra member are executed before the instructions
3562
in the other members of the object are performed.
3564
If you append a built-in install set to the \c INSTALLS variable and do
3565
not specify \c files or \c extra members, \c qmake will decide what needs to
3566
be copied for you. Currently, the only supported built-in install set is
3569
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 82
3571
In the above lines, \c qmake knows what needs to be copied, and will handle
3572
the installation process automatically.
3575
\section1 Cache File
3577
The cache file is a special file \c qmake reads to find settings not specified
3578
in the \c qmake.conf file, project files, or at the command line. If
3579
\c -nocache is not specified when \c qmake is run, it will try to find a file
3580
called \c{.qmake.cache} in parent directories of the current directory. If
3581
it fails to find this file, it will silently ignore this step of processing.
3583
If it finds a \c{.qmake.cache} file then it will process this file first before
3584
it processes the project file.
3587
\section1 Library Dependencies
3589
Often when linking against a library, \c qmake relies on the underlying
3590
platform to know what other libraries this library links against, and
3591
lets the platform pull them in. In many cases, however, this is not
3592
sufficent. For example, when statically linking a library, no other
3593
libraries are linked to, and therefore no dependencies to those
3594
libraries are created. However, an application that later links
3595
against this library will need to know where to find the symbols that
3596
the static library will require. To help with this situation, \c qmake
3597
attempts to follow a library's dependencies where appropriate, but
3598
this behavior must be explicitly enabled by following two steps.
3600
The first step is to enable dependency tracking in the library itself.
3601
To do this you must tell \c qmake to save information about the library:
3603
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 83
3605
This is only relevant to the \c lib template, and will be ignored for
3606
all others. When this option is enabled, \c qmake will create a file
3607
ending in .prl which will save some meta-information about the
3608
library. This metafile is just like an ordinary project file, but only
3609
contains internal variable declarations. You are free to view this file
3610
and, if it is deleted, \c qmake will know to recreate it when necessary,
3611
either when the project file is later read, or if a dependent library
3612
(described below) has changed. When installing this library, by
3613
specifying it as a target in an \c INSTALLS declaration, \c qmake will
3614
automatically copy the .prl file to the installation path.
3616
The second step in this process is to enable reading of this meta
3617
information in the applications that use the static library:
3619
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 84
3621
When this is enabled, \c qmake will process all libraries linked to
3622
by the application and find their meta-information. \c qmake will use
3623
this to determine the relevant linking information, specifically adding
3624
values to the application project file's list of \c DEFINES as well as
3625
\c LIBS. Once \c qmake has processed this file, it will then look through
3626
the newly introduced libraries in the \c LIBS variable, and find their
3627
dependent .prl files, continuing until all libraries have been resolved.
3628
At this point, the Makefile is created as usual, and the libraries are
3629
linked explicitlyy against the application.
3631
The internals of the .prl file are left closed so they can easily
3632
change later. They are not designed to be changed by hand, should only
3633
be created by \c qmake, and should not be transferred between operating
3634
systems as they may contain platform-dependent information.
3637
\section1 File Extensions
3639
Under normal circumstances \c qmake will try to use appropriate file extensions
3640
for your platform. However, it is sometimes necessary to override the default
3641
choices for each platform and explicitly define file extensions for \c qmake to use.
3642
This is achieved by redefining certain built-in variables; for example the extension
3643
used for \l moc files can be redefined with the following assignment in a project
3646
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 85
3648
The following variables can be used to redefine common file extensions recognized
3652
\o QMAKE_EXT_MOC - This modifies the extension placed on included moc files.
3653
\o QMAKE_EXT_UI - This modifies the extension used for designer UI files (usually
3655
\o QMAKE_EXT_PRL - This modifies the extension placed on
3656
\l{#LibDepend}{library dependency files}.
3657
\o QMAKE_EXT_LEX - This changes the suffix used in files (usually in \c LEXSOURCES).
3658
\o QMAKE_EXT_YACC - This changes the suffix used in files (usually in \c YACCSOURCES).
3659
\o QMAKE_EXT_OBJ - This changes the suffix used on generated object files.
3662
All of the above accept just the first value, so you must assign to it just one
3663
value that will be used throughout your project file. There are two variables that
3664
accept a list of values:
3667
\o QMAKE_EXT_CPP - Causes \c qmake to interpret all files with these suffixes as
3669
\o QMAKE_EXT_H - Causes \c qmake to interpret all files with these suffixes as
3670
C and C++ header files.
3674
\section1 Customizing Makefile Output
3676
\c qmake tries to do everything expected of a cross-platform build tool.
3677
This is often less than ideal when you really need to run special
3678
platform-dependent commands. This can be achieved with specific instructions
3679
to the different \c qmake backends.
3681
Customization of the Makefile output is performed through an object-style
3682
API as found in other places in \c qmake. Objects are defined automatically
3683
by specifying their members; for example:
3685
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 86
3687
The definitions above define a \c qmake target called \c mytarget, containing
3688
a Makefile target called \c{.buildfile} which in turn is generated with
3689
the \c touch command. Finally, the \c{.depends} member specifies that
3690
\c mytarget depends on \c mytarget2, another target that is defined afterwards.
3691
\c mytarget2 is a dummy target; it is only defined to echo some text to
3694
The final step is to instruct \c qmake that this object is a target to be built:
3696
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 87
3698
This is all you need to do to actually build custom targets. Of course, you may
3699
want to tie one of these targets to the
3700
\l{qmake Variable Reference#TARGET}{qmake build target}. To do this, you simply need to
3701
include your Makefile target in the list of
3702
\l{qmake Variable Reference#PRE_TARGETDEPS}{PRE_TARGETDEPS}.
3704
The following tables are an overview of the options available to you with the QMAKE_EXTRA_TARGETS
3713
\o The commands for generating the custom build target.
3716
\o Specific configuration options for the custom build target. See the CONFIG table for details.
3719
\o The existing build targets that the custom build target depends on.
3722
\o Specifies which sub-targets should used when creating the rules in the Makefile to call in
3723
the sub-target specific Makefile. This is only used when \c recursive is set in the CONFIG.
3726
\o Specifies the target that should be built via the sub-target Makefile for the rule in the Makefile.
3727
This adds something like $(MAKE) -f Makefile.[subtarget] [recurse_target]. This is only used when
3728
\c recursive is set in the CONFIG.
3731
\o The file being created by the custom build target.
3734
List of members specific to the CONFIG option:
3742
\o Indicates that rules should be created in the Makefile and thus call
3743
the relevant target inside the sub-target specific Makefile. This defaults to creating
3744
an entry for each of the sub-targets.
3747
For convenience, there is also a method of customizing projects
3748
for new compilers or preprocessors:
3750
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 88
3752
With the above definitions, you can use a drop-in replacement for moc if one
3753
is available. The commands is executed on all arguments given to the
3754
\c NEW_HEADERS variable (from the \c input member), and the result is written
3755
to the file defined by the \c output member; this file is added to the
3756
other source files in the project.
3757
Additionally, \c qmake will execute \c depend_command to generate dependency
3758
information, and place this information in the project as well.
3760
These commands can easily be placed into a cache file, allowing subsequent
3761
project files to add arguments to \c NEW_HEADERS.
3763
The following tables are an overview of the options available to you with the QMAKE_EXTRA_COMPILERS
3772
\o The commands used for for generating the output from the input.
3775
\o Specific configuration options for the custom compiler. See the CONFIG table for details.
3778
\o Specifies a command used to generate the list of dependencies for the output.
3781
\o Specifies the type of file the output is, if it is a known type (such as TYPE_C,
3782
TYPE_UI, TYPE_QRC) then it is handled as one of those type of files.
3785
\o Specifies the dependencies of the output file.
3788
\o The variable that contains the files that should be processed with the custom compiler.
3791
\o A description of what the custom compiler is doing. This is only used in some backends.
3794
\o The filename that is created from the custom compiler.
3797
\o Specifies a custom qmake function that is used to specify the filename to be created.
3800
\o The variable that the files created from the output should be added to.
3803
List of members specific to the CONFIG option:
3811
\o The commands used for for generating the output from the input.
3814
\o Specific configuration options for the custom compiler. See the CONFIG table for details.
3817
\o Specifies a command used to generate the list of dependencies for the output.
3820
\o Specifies the type of file the output is, if it is a known type (such as TYPE_C,
3821
TYPE_UI, TYPE_QRC) then it is handled as one of those type of files.
3824
\o Specifies the dependencies of the output file.
3827
\o The variable that contains the files that should be processed with the custom compiler.
3830
\o A description of what the custom compiler is doing. This is only used in some backends.
3833
\o The filename that is created from the custom compiler.
3836
\o Specifies a custom qmake function that is used to specify the filename to be created.
3839
\o Indicates that the variables specified here are replaced with $(QMAKE_COMP_VARNAME) when refered to
3840
in the pro file as $(VARNAME).
3843
\o The variable that the files created from the output should be added to.
3846
List of members specific to the CONFIG option:
3854
\o Indicates that all of the input files are combined into a single output file.
3857
\o Indicates that the output should be added to the list of PRE_TARGETDEPS.
3859
\o explicit_dependencies
3860
\o The dependencies for the output only get generated from the depends member and from
3864
\o Indicates that the output should not be added to the list of objects to be linked in.
3867
\note Symbian platform specific: Generating objects to be linked in is
3868
not supported on the Symbian platform, so either the \c CONFIG option
3869
\c no_link or variable \c variable_out should always be defined for
3875
\page qmake-advanced-usage.html
3876
\title qmake Advanced Usage
3877
\contentspage {qmake Manual}{Contents}
3878
\previouspage qmake Platform Notes
3879
\nextpage Using Precompiled Headers
3881
Many \c qmake project files simply describe the sources and header files used
3882
by the project, using a list of \c{name = value} and \c{name += value}
3883
definitions. \c qmake also provides other operators, functions, and scopes
3884
that can be used to process the information supplied in variable declarations.
3885
These advanced features allow Makefiles to be generated for multiple platforms
3886
from a single project file.
3892
In many project files, the assignment (\c{=}) and append (\c{+=}) operators can
3893
be used to include all the information about a project. The typical pattern of
3894
use is to assign a list of values to a variable, and append more values
3895
depending on the result of various tests. Since \c qmake defines certain
3896
variables using default values, it is sometimes necessary to use the removal
3897
(\c{-=}) operator to filter out values that are not required. The following
3898
operators can be used to manipulate the contents of variables.
3900
The \c = operator assigns a value to a variable:
3902
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 89
3904
The above line sets the \c TARGET variable to \c myapp. This will overwrite any
3905
values previously set for \c TARGET with \c myapp.
3907
The \c += operator appends a new value to the list of values in a variable:
3909
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 90
3911
The above line appends \c QT_DLL to the list of pre-processor defines to be put
3912
in the generated Makefile.
3914
The \c -= operator removes a value from the list of values in a variable:
3916
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 91
3918
The above line removes \c QT_DLL from the list of pre-processor defines to be
3919
put in the generated Makefile.
3921
The \c *= operator adds a value to the list of values in a variable, but only
3922
if it is not already present. This prevents values from being included many
3923
times in a variable. For example:
3925
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 92
3927
In the above line, \c QT_DLL will only be added to the list of pre-processor
3928
defines if it is not already defined. Note that the
3929
\l{qmake Function Reference#unique}{unique()}
3930
function can also be used to ensure that a variables only contains one
3931
instance of each value.
3933
The \c ~= operator replaces any values that match a regular expression with
3934
the specified value:
3936
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 93
3938
In the above line, any values in the list that start with \c QT_D or \c QT_T are
3939
replaced with \c QT.
3941
The \c $$ operator is used to extract the contents of a variable, and can be
3942
used to pass values between variables or supply them to functions:
3944
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 94
3949
Scopes are similar to \c if statements in procedural programming languages.
3950
If a certain condition is true, the declarations inside the scope are processed.
3954
Scopes consist of a condition followed by an opening brace on the same line,
3955
a sequence of commands and definitions, and a closing brace on a new line:
3957
\snippet doc/src/snippets/qmake/scopes.pro syntax
3959
The opening brace \e{must be written on the same line as the condition}.
3960
Scopes may be concatenated to include more than one condition; see below
3963
\section2 Scopes and Conditions
3965
A scope is written as a condition followed by a series of declarations
3966
contained within a pair of braces; for example:
3968
\snippet doc/src/snippets/qmake/scopes.pro 0
3970
The above code will add the \c paintwidget_win.cpp file to the sources listed
3971
in the generated Makefile if \c qmake is used on a Windows platform.
3972
If \c qmake is used on a platform other than Windows, the define will be
3975
The conditions used in a given scope can also be negated to provide an
3976
alternative set of declarations that will be processed only if the
3977
original condition is false. For example, suppose we want to process
3978
something on all platforms \e except for Windows. We can achieve this by
3979
negating the scope like this:
3981
\snippet doc/src/snippets/qmake/scopes.pro 1
3983
Scopes can be nested to combine more than one condition. For instance, if
3984
you want to include a particular file for a certain platform only if
3985
debugging is enabled then you write the following:
3987
\snippet doc/src/snippets/qmake/scopes.pro 2
3989
To save writing many nested scopes, you can nest scopes using the \c :
3990
operator. The nested scopes in the above example can be rewritten in
3993
\snippet doc/src/snippets/qmake/scopes.pro 3
3995
You may also use the \c : operator to perform single line conditional
3996
assignments; for example:
3998
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 95
4000
The above line adds \c QT_DLL to the \c DEFINES variable only on the
4002
Generally, the \c : operator behaves like a logical AND operator, joining
4003
together a number of conditions, and requiring all of them to be true.
4005
There is also the \c | operator to act like a logical OR operator, joining
4006
together a number of conditions, and requiring only one of them to be true.
4008
\snippet doc/src/snippets/qmake/scopes.pro 4
4010
You can also provide alternative declarations to those within a scope by
4011
using an \c else scope. Each \c else scope is processed if the conditions
4012
for the preceding scopes are false.
4013
This allows you to write complex tests when combined with other scopes
4014
(separated by the \c : operator as above). For example:
4016
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 96
4018
\section2 Configuration and Scopes
4020
The values stored in the
4021
\l{qmake-project-files.html#GeneralConfiguration}{\c CONFIG variable}
4022
are treated specially by \c qmake. Each of the possible values can be
4023
used as the condition for a scope. For example, the list of values
4024
held by \c CONFIG can be extended with the \c opengl value:
4026
\snippet doc/src/snippets/qmake/configscopes.pro 0
4028
As a result of this operation, any scopes that test for \c opengl will
4029
be processed. We can use this feature to give the final executable an
4032
\snippet doc/src/snippets/qmake/configscopes.pro 1
4033
\snippet doc/src/snippets/qmake/configscopes.pro 2
4034
\snippet doc/src/snippets/qmake/configscopes.pro 3
4036
This feature makes it easy to change the configuration for a project
4037
without losing all the custom settings that might be needed for a specific
4038
configuration. In the above code, the declarations in the first scope are
4039
processed, and the final executable will be called \c application-gl.
4040
However, if \c opengl is not specified, the declarations in the second
4041
scope are processed instead, and the final executable will be called
4044
Since it is possible to put your own values on the \c CONFIG
4045
line, this provides you with a convenient way to customize project files
4046
and fine-tune the generated Makefiles.
4048
\section2 Platform Scope Values
4050
In addition to the \c win32, \c macx, and \c unix values used in many
4051
scope conditions, various other built-in platform and compiler-specific
4052
values can be tested with scopes. These are based on platform
4053
specifications provided in Qt's \c mkspecs directory. For example, the
4054
following lines from a project file show the current specification in
4055
use and test for the \c linux-g++ specification:
4057
\snippet doc/src/snippets/qmake/specifications.pro 0
4059
You can test for any other platform-compiler combination as long as a
4060
specification exists for it in the \c mkspecs directory.
4062
The scope \c unix is true for the Symbian platform.
4066
Many of the variables used in project files are special variables that
4067
\c qmake uses when generating Makefiles, such as \c DEFINES, \c SOURCES,
4068
and \c HEADERS. It is possible for you to create variables for your own
4069
use; \c qmake creates new variables with a given name when it encounters
4070
an assignment to that name. For example:
4072
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 97
4074
There are no restricitions on what you do to your own variables, as \c
4075
qmake will ignore them unless it needs to evaluate them when processing
4078
You can also assign the value of a current variable to another
4079
variable by prefixing $$ to the variable name. For example:
4081
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 98
4083
Now the MY_DEFINES variable contains what is in the DEFINES variable at
4084
this point in the project file. This is also equivalent to:
4086
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 99
4088
The second notation allows you to append the contents of the variable to
4089
another value without separating the two with a space. For example, the
4090
following will ensure that the final executable will be given a name
4091
that includes the project template being used:
4093
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 100
4095
Variables can be used to store the contents of environment variables.
4096
These can be evaluated at the time that \c qmake is run, or included
4097
in the generated Makefile for evaluation when the project is built.
4099
To obtain the contents of an environment value when \c qmake is run,
4100
use the \c $$(...) operator:
4102
\snippet doc/src/snippets/qmake/environment.pro 0
4104
In the above assignment, the value of the \c PWD environment variable
4105
is read when the project file is processed.
4107
To obtain the contents of an environment value at the time when the
4108
generated Makefile is processed, use the \c $(...) operator:
4110
\snippet doc/src/snippets/qmake/environment.pro 1
4112
In the above assignment, the value of \c PWD is read immediately
4113
when the project file is processed, but \c $(PWD) is assigned to
4114
\c DESTDIR in the generated Makefile. This makes the build process
4115
more flexible as long as the environment variable is set correctly
4116
when the Makefile is processed.
4118
The special \c $$[...] operator can be used to access various
4119
configuration options that were set when Qt was built:
4121
\snippet doc/src/snippets/qmake/qtconfiguration.pro 0
4123
The variables accessible with this operator are typically used to
4124
enable third party plugins and components to be integrated with Qt.
4125
For example, a \QD plugin can be installed alongside \QD's built-in
4126
plugins if the following declaration is made in its project file:
4128
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 101
4130
\target VariableProcessingFunctions
4131
\section1 Variable Processing Functions
4133
\c qmake provides a selection of built-in functions to allow the
4134
contents of variables to be processed. These functions process the
4135
arguments supplied to them and return a value, or list of values, as
4136
a result. In order to assign a result to a variable, it is necessary
4137
to use the \c $$ operator with this type of function in the same way
4138
used to assign contents of one variable to another:
4140
\snippet doc/src/snippets/qmake/functions.pro 1
4142
This type of function should be used on the right-hand side of
4143
assignments (i.e, as an operand).
4145
It is possible to define your own functions for processing the
4146
contents of variables. These functions can be defined in the following
4149
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 102
4151
The following example function takes a variable name as its only
4152
argument, extracts a list of values from the variable with the
4153
\l{qmake-function-reference.html}{eval()} built-in function,
4154
and compiles a list of files:
4156
\snippet doc/src/snippets/qmake/replacefunction.pro 0
4158
\target ConditionalFunctions
4159
\section1 Conditional Functions
4161
\c qmake provides built-in functions that can be used as conditions
4162
when writing scopes. These functions do not return a value, but
4163
instead indicate "success" or "failure":
4165
\snippet doc/src/snippets/qmake/functions.pro 3
4167
This type of function should be used in conditional expressions
4170
It is possible to define your own functions to provide conditions
4171
for scopes. The following example tests whether each file in a list
4172
exists and returns true if they all exist, or false if not:
4174
\snippet doc/src/snippets/qmake/testfunction.pro 0
4176
\section1 Adding New Configuration Features
4178
\c qmake lets you create your own \e features that can be included in
4179
project files by adding their names to the list of values specified by
4180
the \c CONFIG variable. Features are collections of custom functions and
4181
definitions in \c{.prf} files that can reside in one of many standard
4182
directories. The locations of these directories are defined in a number
4183
of places, and \c qmake checks each of them in the following order when
4184
it looks for \c{.prf} files:
4187
\o In a directory listed in the \c QMAKEFEATURES environment variable;
4188
this contains a colon-separated list of directories.
4189
\o In a directory listed in the \c QMAKEFEATURES property variable; this
4190
contains a colon-spearated list of directories.
4192
\o In a features directory beneath the project's root directory (where
4193
the \c{.qmake.cache} file is generated).
4195
\o In a features directory residing within a \c mkspecs directory.
4196
\c mkspecs directories can be located beneath any of the directories
4197
listed in the \c QMAKEPATH environment variable (a colon-separated list
4198
of directories). (\c{$QMAKEPATH/mkspecs/<features>})
4199
\o In a features directory residing beneath the directory provided by the
4200
\c QMAKESPEC environment variable. (\c{$QMAKESPEC/<features>})
4201
\o In a features directory residing in the \c data_install/mkspecs directory.
4202
(\c{data_install/mkspecs/<features>})
4203
\o In a features directory that exists as a sibling of the directory
4204
specified by the \c QMAKESPEC environment variable.
4205
(\c{$QMAKESPEC/../<features>})
4208
The following features directories are searched for features files:
4211
\o \c{features/unix}, \c{features/win32}, or \c{features/macx}, depending on
4216
For example, consider the following assignment in a project file:
4218
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 103
4220
With this addition to the \c CONFIG variable, \c qmake will search the
4221
locations listed above for the \c myfeatures.prf file after it has
4222
finished parsing your project file. On Unix systems, it will look for
4226
\o \c $QMAKEFEATURES/myfeatures.prf (for each directory listed in the
4227
\c QMAKEFEATURES environment variable)
4228
\o \c $$QMAKEFEATURES/myfeatures.prf (for each directory listed in the
4229
\c QMAKEFEATURES property variable)
4230
\o \c myfeatures.prf (in the project's root directory)
4231
\o \c $QMAKEPATH/mkspecs/features/unix/myfeatures.prf and
4232
\c $QMAKEPATH/mkspecs/features/myfeatures.prf (for each directory
4233
listed in the \c QMAKEPATH environment variable)
4234
\o \c $QMAKESPEC/features/unix/myfeatures.prf and
4235
\c $QMAKESPEC/features/myfeatures.prf
4236
\o \c data_install/mkspecs/features/unix/myfeatures.prf and
4237
\c data_install/mkspecs/features/myfeatures.prf
4238
\o \c $QMAKESPEC/../features/unix/myfeatures.prf and
4239
\c $QMAKESPEC/../features/myfeatures.prf
4242
\note The \c{.prf} files must have names in lower case.
4248
\page qmake-precompiledheaders.html
4249
\title Using Precompiled Headers
4250
\contentspage {qmake Manual}{Contents}
4251
\previouspage qmake Advanced Usage
4252
\nextpage qmake Reference
4254
\target Introduction
4256
Precompiled headers are a performance feature supported by some
4257
compilers to compile a stable body of code, and store the compiled
4258
state of the code in a binary file. During subsequent compilations,
4259
the compiler will load the stored state, and continue compiling the
4260
specified file. Each subsequent compilation is faster because the
4261
stable code does not need to be recompiled.
4263
\c qmake supports the use of precompiled headers (PCH) on some
4264
platforms and build environments, including:
4269
\o Dsp projects (VC 6.0)
4270
\o Vcproj projects (VC 7.0 \& 7.1)
4279
\o GCC 3.4 and above
4284
\section1 Adding Precompiled Headers to Your Project
4286
\target PCH_CONTENTS
4287
\section2 Contents of the Precompiled Header File
4289
The precompiled header must contain code which is \e stable
4290
and \e static throughout your project. A typical PCH might look
4293
\section3 Example: \c stable.h
4295
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 104
4297
Note that a precompiled header file needs to separate C includes from
4298
C++ includes, since the precompiled header file for C files may not
4301
\target PROJECT_OPTIONS
4302
\section2 Project Options
4304
To make your project use PCH, you only need to define the
4305
\c PRECOMPILED_HEADER variable in your project file:
4307
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 105
4309
\c qmake will handle the rest, to ensure the creation and use of the
4310
precompiled header file. You do not need to include the precompiled
4311
header file in \c HEADERS, as \c qmake will do this if the configuration
4314
All platforms that support precompiled headers have the configuration
4315
option \c precompile_header set. Using this option, you may trigger
4316
conditional blocks in your project file to add settings when using PCH.
4319
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 106
4321
\section1 Notes on Possible Issues
4323
On some platforms, the file name suffix for precompiled header files is
4324
the same as that for other object files. For example, the following
4325
declarations may cause two different object files with the same name to
4328
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 107
4330
To avoid potential conflicts like these, it is good practice to ensure
4331
that header files that will be precompiled are given distinctive names.
4333
\target EXAMPLE_PROJECT
4334
\section1 Example Project
4336
You can find the following source code in the
4337
\c{examples/qmake/precompile} directory in the Qt distribution:
4339
\section2 \c mydialog.ui
4341
\quotefromfile examples/qmake/precompile/mydialog.ui
4344
\section2 \c stable.h
4346
\snippet examples/qmake/precompile/stable.h 0
4348
\section2 \c myobject.h
4350
\snippet examples/qmake/precompile/myobject.h 0
4352
\section2 \c myobject.cpp
4354
\snippet examples/qmake/precompile/myobject.cpp 0
4356
\section2 \c util.cpp
4358
\snippet examples/qmake/precompile/util.cpp 0
4360
\section2 \c main.cpp
4362
\snippet examples/qmake/precompile/main.cpp 0
4364
\section2 \c precompile.pro
4366
\snippet examples/qmake/precompile/precompile.pro 0
4370
\page qmake-tutorial.html
4371
\title qmake Tutorial
4372
\contentspage {qmake Manual}{Contents}
4373
\previouspage qmake Manual
4374
\nextpage qmake Common Projects
4376
This tutorial teaches you how to use \c qmake. We recommend that
4377
you read the \c qmake user guide after completing this tutorial.
4379
\section1 Starting off Simple
4381
Let's assume that you have just finished a basic implementation of
4382
your application, and you have created the following files:
4390
You will find these files in the \c{examples/qmake/tutorial} directory
4391
of the Qt distribution. The only other thing you know about the setup of
4392
the application is that it's written in Qt. First, using your favorite
4393
plain text editor, create a file called \c hello.pro in
4394
\c{examples/qmake/tutorial}. The first thing you need to do is add the
4395
lines that tell \c qmake about the source and header files that are part
4396
of your development project.
4398
We'll add the source files to the project file first. To do this you
4399
need to use the \l{qmake Variable Reference#SOURCES}{SOURCES} variable.
4400
Just start a new line with \c {SOURCES +=} and put hello.cpp after it.
4401
You should have something like this:
4403
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 108
4405
We repeat this for each source file in the project, until we end up
4408
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 109
4410
If you prefer to use a Make-like syntax, with all the files listed in
4411
one go you can use the newline escaping like this:
4413
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 110
4415
Now that the source files are listed in the project file, the header
4416
files must be added. These are added in exactly the same way as source
4417
files, except that the variable name we use is
4418
\l{qmake Variable Reference#HEADERS}{HEADERS}.
4420
Once you have done this, your project file should look something like
4423
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 111
4425
The target name is set automatically; it is the same as the project
4426
file, but with the suffix appropriate to the platform. For example, if
4427
the project file is called \c hello.pro, the target will be \c hello.exe
4428
on Windows and \c hello on Unix. If you want to use a different name
4429
you can set it in the project file:
4431
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 112
4433
The final step is to set the \l{qmake Variable Reference#CONFIG}{CONFIG}
4434
variable. Since this is a Qt application, we need to put \c qt on the
4435
\c CONFIG line so that \c qmake will add the relevant libraries to be
4436
linked against and ensure that build lines for \c moc and \c uic are
4437
included in the generated Makefile.
4439
The finished project file should look like this:
4441
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 113
4443
You can now use \c qmake to generate a Makefile for your application.
4444
On the command line, in your project's directory, type the following:
4446
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 114
4448
Then type \c make or \c nmake depending on the compiler you use.
4450
For Visual Studio users, \c qmake can also generate \c .dsp or
4451
\c .vcproj files, for example:
4453
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 115
4455
\section1 Making an Application Debuggable
4457
The release version of an application doesn't contain any debugging
4458
symbols or other debugging information. During development it is useful
4459
to produce a debugging version of the application that has the
4460
relevant information. This is easily achieved by adding \c debug to the
4461
\c CONFIG variable in the project file.
4465
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 116
4467
Use \c qmake as before to generate a Makefile and you will be able to
4468
obtain useful information about your application when running it in
4469
a debugging environment.
4471
\section1 Adding Platform-Specific Source Files
4473
After a few hours of coding, you might have made a start on the
4474
platform-specific part of your application, and decided to keep the
4475
platform-dependent code separate. So you now have two new files to
4476
include into your project file: \c hellowin.cpp and \c
4477
hellounix.cpp. We can't just add these to the \c SOURCES
4478
variable since this will put both files in the Makefile. So, what we
4479
need to do here is to use a scope which will be processed depending on
4480
which platform \c qmake is run on.
4482
A simple scope that will add in the platform-dependent file for
4483
Windows looks like this:
4485
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 117
4487
So if \c qmake is run on Windows, it will add \c hellowin.cpp to the
4488
list of source files. If \c qmake is run on any other platform, it
4489
will simply ignore it. Now all that is left to be done is to create a
4490
scope for the Unix-specific file.
4492
When you have done that, your project file should now look
4493
something like this:
4495
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 118
4497
Use \c qmake as before to generate a Makefile.
4499
\section1 Stopping qmake If a File Doesn't Exist
4501
You may not want to create a Makefile if a certain file doesn't exist.
4502
We can check if a file exists by using the exists() function. We can
4503
stop \c qmake from processing by using the error() function. This
4504
works in the same way as scopes do. Simply replace the scope condition
4505
with the function. A check for a \c main.cpp file looks like this:
4507
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 119
4509
The \c{!} symbol is used to negate the test; i.e. \c{exists( main.cpp )}
4510
is true if the file exists, and \c{!exists( main.cpp )} is true if the
4513
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 120
4515
Use \c qmake as before to generate a makefile. If you rename \c
4516
main.cpp temporarily, you will see the message and \c qmake will stop
4519
\section1 Checking for More than One Condition
4521
Suppose you use Windows and you want to be able to see statement
4522
output with qDebug() when you run your application on the command line.
4523
Unless you build your application with the appropriate console setting,
4524
you won't see the output. We can easily put \c console on the \c CONFIG
4525
line so that on Windows the makefile will have this setting. However,
4526
let's say that we only want to add the \c CONFIG line if we are running
4527
on Windows \e and when \c debug is already on the \c CONFIG line.
4528
This requires using two nested scopes; just create one scope, then create
4529
the other inside it. Put the settings to be processed inside the last
4532
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 121
4534
Nested scopes can be joined together using colons, so the final
4535
project file looks like this:
4537
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 122
4539
That's it! You have now completed the tutorial for \c qmake, and are
4540
ready to write project files for your development projects.
4544
\page qmake-common-projects.html
4545
\title qmake Common Projects
4546
\contentspage {qmake Manual}{Contents}
4547
\previouspage qmake Tutorial
4548
\nextpage Using qmake
4550
This chapter describes how to set up \c qmake project files for three
4551
common project types that are based on Qt. Although all kinds of
4552
projects use many of the same variables, each of them use project-specific
4553
variables to customize output files.
4555
Platform-specific variables are not described here; we refer the reader to
4556
the \l{Deploying Qt Applications} document for information on issues such as
4557
\l{Deploying an Application on Mac OS X#Architecture Dependencies}{building
4558
universal binaries for Mac OS X} and
4559
\l{Deploying an Application on Windows#Visual Studio 2005 Onwards}
4560
{handling Visual Studio manifest files}.
4565
\section1 Building an Application
4567
\section2 The app Template
4569
The \c app template tells \c qmake to generate a Makefile that will build
4570
an application. With this template, the type of application can be specified
4571
by adding one of the following options to the \c CONFIG variable definition:
4574
\header \o Option \o Description
4575
\row \o windows \o The application is a Windows GUI application.
4576
\row \o console \o \c app template only: the application is a Windows console
4580
When using this template the following \c qmake system variables are recognized.
4581
You should use these in your .pro file to specify information about your
4585
\o HEADERS - A list of all the header files for the application.
4586
\o SOURCES - A list of all the source files for the application.
4587
\o FORMS - A list of all the UI files (created using \c{Qt Designer})
4588
for the application.
4589
\o LEXSOURCES - A list of all the lex source files for the application.
4590
\o YACCSOURCES - A list of all the yacc source files for the application.
4591
\o TARGET - Name of the executable for the application. This defaults
4592
to the name of the project file. (The extension, if any, is added
4594
\o DESTDIR - The directory in which the target executable is placed.
4595
\o DEFINES - A list of any additional pre-processor defines needed for the application.
4596
\o INCLUDEPATH - A list of any additional include paths needed for the application.
4597
\o DEPENDPATH - The dependency search path for the application.
4598
\o VPATH - The search path to find supplied files.
4599
\o DEF_FILE - Windows only: A .def file to be linked against for the application.
4600
\o RC_FILE - Windows only: A resource file for the application.
4601
\o RES_FILE - Windows only: A resource file to be linked against for the application.
4604
You only need to use the system variables that you have values for,
4605
for instance, if you do not have any extra INCLUDEPATHs then you do not
4606
need to specify any, \c qmake will add in the default ones needed.
4607
For instance, an example project file might look like this:
4609
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 123
4611
For items that are single valued, e.g. the template or the destination
4612
directory, we use "="; but for multi-valued items we use "+=" to \e
4613
add to the existing items of that type. Using "=" replaces the item's
4614
value with the new value, for example if we wrote \c{DEFINES=QT_DLL},
4615
all other definitions would be deleted.
4618
\section1 Building a Library
4620
\section2 The lib Template
4622
The \c lib template tells \c qmake to generate a Makefile that will
4623
build a library. When using this template, in addition to the system variables
4624
mentioned above for the \c app template the \c VERSION variable is
4625
supported. You should use these in your .pro file to specify
4626
information about the library.
4628
When using the \c lib template, the following options can be added to the
4629
\c CONFIG variable to determine the type of library that is built:
4632
\header \o Option \o Description
4633
\row \o dll \o The library is a shared library (dll).
4634
\row \o staticlib \o The library is a static library.
4635
\row \o plugin \o The library is a plugin; this also enables the dll option.
4638
The following option can also be defined to provide additional information about
4642
\o VERSION - The version number of the target library, for example, 2.3.1.
4645
The target file name for the library is platform-dependent. For example, on
4646
X11 and Mac OS X, the library name will be prefixed by \c lib; on Windows,
4647
no prefix is added to the file name.
4650
\section1 Building a Plugin
4652
Plugins are built using the \c lib template, as described in the previous
4653
section. This tells \c qmake to generate a Makefile for the project that will
4654
build a plugin in a suitable form for each platform, usually in the form of a
4655
library. As with ordinary libraries, the \c VERSION variable is used to specify
4656
information about the plugin.
4659
\o VERSION - The version number of the target library, for example, 2.3.1.
4662
\section2 Building a Qt Designer Plugin
4664
\QD plugins are built using a specific set of configuration settings that
4665
depend on the way Qt was configured for your system. For convenience, these
4666
settings can be enabled by adding \c designer to the project's \c CONFIG
4667
variable. For example:
4669
\snippet examples/designer/worldtimeclockplugin/worldtimeclockplugin.pro 0
4671
See the \l{Qt Designer Examples} for more examples of plugin-based projects.
4673
\section1 Building and Installing in Debug and Release Modes
4675
Sometimes, it is necessary to build a project in both debug and release
4676
modes. Although the \c CONFIG variable can hold both \c debug and \c release
4677
options, the \c debug option overrides the \c release option.
4679
\section2 Building in Both Modes
4681
To enable a project to be built in both modes, you must add the
4682
\c debug_and_release option to your project's \c CONFIG definition:
4684
\snippet doc/src/snippets/qmake/debug_and_release.pro 0
4685
\snippet doc/src/snippets/qmake/debug_and_release.pro 1
4687
The scope in the above snippet modifies the build target in each mode to
4688
ensure that the resulting targets have different names. Providing different
4689
names for targets ensures that one will not overwrite the other.
4691
When \c qmake processes the project file, it will generate a Makefile rule
4692
to allow the project to be built in both modes. This can be invoked in the
4695
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 124
4697
The \c build_all option can be added to the \c CONFIG variable in the
4698
project file to ensure that the project is built in both modes by default:
4700
\snippet doc/src/snippets/qmake/debug_and_release.pro 2
4702
This allows the Makefile to be processed using the default rule:
4704
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 125
4706
\section2 Installing in Both Modes
4708
The \c build_all option also ensures that both versions of the target
4709
will be installed when the installation rule is invoked:
4711
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 126
4713
It is possible to customize the names of the build targets depending on
4714
the target platform. For example, a library or plugin may be named using a
4715
different convention on Windows to the one used on Unix platforms:
4718
Note: This was originally used in the customwidgetplugin.pro file, but is
4719
no longer needed there.
4721
\snippet doc/src/snippets/code/doc_src_qmake-manual.qdoc 127
4723
The default behavior in the above snippet is to modify the name used for
4724
the build target when building in debug mode. An \c else clause could be
4725
added to the scope to do the same for release mode; left as it is, the
4726
target name remains unmodified.
added
removed
doc/src/development/qmake-manual.qdoc
