zoukankan      html  css  js  c++  java

  • qt 4.6 qmake Reference

    qt 4.6 qmake Reference

    qmake Function Reference  https://blog.csdn.net/pcliuguangtao/article/details/7241513

    qmake Variable Reference  https://blog.csdn.net/pcliuguangtao/article/details/7241504

    qmake Function Reference

    qmake provides built-in functions to allow the contents of variables to be processed, and to enable tests to be performed during the configuration process. Functions that process the contents of variables typically return values that can be assigned to other variables, and these values are obtained by prefixing function with the $$ operator. Functions that perform tests are usually used as the conditional parts of scopes; these are indicated in the function descriptions below.

    basename(variablename)

    Returns the basename of the file specified. For example:

     FILE = /etc/passwd
 FILENAME = $$basename(FILE) #passwd

    CONFIG(config)

    [Conditional]

    This function can be used to test for variables placed into the CONFIG variable. This is the same as regular old style (tmake) scopes, but has the added advantage a second parameter can be passed to test for the active config. As the order of values is important in CONFIG variables (i.e. the last one set will be considered the active config for mutually exclusive values) a second parameter can be used to specify a set of values to consider. For example:

     CONFIG = debug
 CONFIG += release
 CONFIG(release, debug|release):message(Release build!) #will print
 CONFIG(debug, debug|release):message(Debug build!) #no print

    Because release is considered the active setting (for feature parsing) it will be the CONFIG used to generate the build file. In the common case a second parameter is not needed, but for specific mutual exclusive tests it is invaluable.

    contains(variablename, value)

    [Conditional]

    Succeeds if the variable variablename contains the value value; otherwise fails. You can check the return value of this function using a scope.

    For example:

     contains( drivers, network ) {
     # drivers contains 'network'
     message( "Configuring for network build..." )
     HEADERS += network.h
     SOURCES += network.cpp
 }

    The contents of the scope are only processed if the drivers variable contains the value, network. If this is the case, the appropriate files are added to the SOURCES andHEADERS variables.

    count(variablename, number)

    [Conditional]

    Succeeds if the variable variablename contains a list with the specified number of value; otherwise fails.

    This function is used to ensure that declarations inside a scope are only processed if the variable contains the correct number of values; for example:

     options = $$find(CONFIG, "debug") $$find(CONFIG, "release")
 count(options, 2) {
     message(Both release and debug specified.)
 }

    dirname(file)

    Returns the directory name part of the specified file. For example:

     FILE = /etc/X11R6/XF86Config
 DIRNAME = $$dirname(FILE) #/etc/X11R6

    error(string)

    This function never returns a value. qmake displays the given string to the user, and exits. This function should only be used for unrecoverable errors.

    For example:

     error(An error has occurred in the configuration process.)

    eval(string)

    [Conditional]

    Evaluates the contents of the string using qmake's syntax rules and returns true. Definitions and assignments can be used in the string to modify the values of existing variables or create new definitions.

    For example:

     eval(TARGET = myapp) {
     message($$TARGET)
 }

    Note that quotation marks can be used to delimit the string, and that the return value can be discarded if it is not needed.

    exists(filename)

    [Conditional]

    Tests whether a file with the given filename exists. If the file exists, the function succeeds; otherwise it fails. If a regular expression is specified for the filename, this function succeeds if any file matches the regular expression specified.

    For example:

     exists( $(QTDIR)/lib/libqt-mt* ) {
       message( "Configuring for multi-threaded Qt..." )
       CONFIG += thread
 }

    Note that "/" can be used as a directory separator, regardless of the platform in use.

    find(variablename, substr)

    Places all the values in variablename that match substr. substr may be a regular expression, and will be matched accordingly.

     MY_VAR = one two three four
 MY_VAR2 = $$join(MY_VAR, " -L", -L) -Lfive
 MY_VAR3 = $$member(MY_VAR, 2) $$find(MY_VAR, t.*)

    MY_VAR2 will contain '-Lone -Ltwo -Lthree -Lfour -Lfive', and MY_VAR3 will contains 'three two three'.

    for(iterate, list)

    This special test function will cause a loop to be started that iterates over all values in list, setting iterate to each value in turn. As a convenience, if list is 1..10 then iterate will iterate over the values 1 through 10.

    The use of an else scope afer a condition line with a for() loop is disallowed.

    For example:

     LIST = 1 2 3
 for(a, LIST):exists(file.$${a}):message(I see a file.$${a}!)

    include(filename)

    [Conditional]

    Includes the contents of the file specified by filename into the current project at the point where it is included. This function succeeds if filename is included; otherwise it fails. The included file is processed immediately.

    You can check whether the file was included by using this function as the condition for a scope; for example:

     include( shared.pri )
 OPTIONS = standard custom
 !include( options.pri ) {
     message( "No custom build options specified" )
 OPTIONS -= custom
 }

    infile(filename, var, val)

    [Conditional]

    Succeeds if the file filename (when parsed by qmake itself) contains the variable var with a value of val; otherwise fails. If you do not specify a third argument (val), the function will only test whether var has been declared in the file.

    isEmpty(variablename)

    [Conditional]

    Succeeds if the variable variablename is empty; otherwise fails. This is the equivalent of count( variablename, 0 ).

    For example:

     isEmpty( CONFIG ) {
 CONFIG += qt warn_on debug
 }

    join(variablename, glue, before, after)

    Joins the value of variablename with glue. If this value is non-empty it prefixes the value with before and suffix it with after. variablename is the only required field, the others default to empty strings. If you need to encode spaces in glue, before, or after you must quote them.

    member(variablename, position)

    Returns the value at the given position in the list of items in variablename. If an item cannot be found at the position specified, an empty string is returned. variablenameis the only required field. If not specified, position defaults to 0, causing the first value in the list to be returned.

    message(string)

    This function simply writes a message to the console. Unlike the error() function, this function allows processing to continue.

     message( "This is a message" )

    The above line causes "This is a message" to be written to the console. The use of quotation marks is optional.

    Note: By default, messages are written out for each Makefile generated by qmake for a given project. If you want to ensure that messages only appear once for each project, test the build_pass variable in conjunction with a scope to filter out messages during builds; for example:

     !build_pass:message( "This is a message" )

    prompt(question)

    Displays the specified question, and returns a value read from stdin.

    quote(string)

    Converts a whole string into a single entity and returns the result. Newlines, carriage returns, and tabs can be specified in the string with and . The return value does not contain either single or double quotation marks unless you explicitly include them yourself, but will be placed into a single entry (for literal expansion).

    replace(string, old_string, new_string)

    Replaces each instance of old_string with new_string in the contents of the variable supplied as string. For example, the code

     MESSAGE = This is a tent.
 message($$replace(MESSAGE, tent, test))

    prints the message:

     This is a test.

    sprintf(string, arguments...)

    Replaces %1-%9 with the arguments passed in the comma-separated list of function arguments and returns the processed string.

    system(command)

    [Conditional]

    Executes the given command in a secondary shell, and succeeds if the command returns with a zero exit status; otherwise fails. You can check the return value of this function using a scope:

    For example:

     system(ls /bin):HAS_BIN=FALSE

    Alternatively, you can use this function to obtain stdout and stderr from the command, and assign it to a variable. For example, you can use this to interrogate information about the platform:

     UNAME = $$system(uname -s)
 contains( UNAME, [lL]inux ):message( This looks like Linux ($$UNAME) to me )

    unique(variablename)

    This will return a list of values in variable that are unique (that is with repetitive entries removed). For example:

     ARGS = 1 2 3 2 5 1
 ARGS = $$unique(ARGS) #1 2 3 5

    warning(string)

    This function will always succeed, and will display the given string to the user. message() is a synonym for warning().

    [Previous: qmake Variable Reference] [Contents] [Next: Configuring qmake's Environment]

    qmake Variable Reference

    qmake's fundamental behavior is influenced by variable declarations that define the build process of each project. Some of these declare resources, such as headers and source files, that are common to each platform; others are used to customize the behavior of compilers and linkers on specific platforms.

    Platform-specific variables follow the naming pattern of the variables which they extend or modify, but include the name of the relevant platform in their name. For example, QMAKE_LIBS can be used to specify a list of libraries that a project needs to link against, and QMAKE_LIBS_X11 can be used to extend or override this list.

    BLD_INF_RULES

    This is only used on the Symbian platform.

    Generic bld.inf file content can be specified with BLD_INF_RULES variables. The section of bld.inf file where each rule goes is appended to BLD_INF_RULES with a dot.

    For example:

     DEPLOYMENT.installer_header = 0x12345678

    This will add the specified statements to the prj_exports section of the generated bld.inf file.

    It is also possible to add multiple rows in a single block. Each double quoted string will be placed on a new row in the generated bld.inf file.

    For example:

     myextension = 
     "start extension myextension" 
     "$${LITERAL_HASH}if defined(WINSCW)" 
     "option MYOPTION foo" 
     "$${LITERAL_HASH}endif" 
     "option MYOPTION bar" 
     "end"
 BLD_INF_RULES.prj_extensions += myextension

    Any rules you define will be added after automatically generated rules in each section.

    CONFIG

    The CONFIG variable specifies project configuration and compiler options. The values will be recognized internally by qmake and have special meaning. They are as follows.

    These CONFIG values control compilation flags:

    OptionDescription
    release The project is to be built in release mode. This is ignored if debug is also specified.
    debug The project is to be built in debug mode.
    debug_and_release The project is built in both debug and release modes. This can have some unexpected side effects (see below for more information).
    build_all If debug_and_release is specified, the project is built in both debug and release modes by default.
    ordered When using the subdirs template, this option specifies that the directories listed should be processed in the order in which they are given.
    precompile_header Enables support for the use of precompiled headers in projects.
    warn_on The compiler should output as many warnings as possible. This is ignored if warn_off is specified.
    warn_off The compiler should output as few warnings as possible.

    Since the debug option overrides the release option when both are defined in the CONFIG variable, it is necessary to use the debug_and_release option if you want to allow both debug and release versions of a project to be built. In such a case, the Makefile that qmake generates includes a rule that builds both versions, and this can be invoked in the following way:

     make all

    When linking a library, qmake relies on the underlying platform to know what other libraries this library links against. However, if linking statically, qmake will not get this information unless we use the following CONFIG options:

    OptionDescription
    create_prl This option enables qmake to track these dependencies. When this option is enabled, qmake will create a file ending in .prl which will save meta-information about the library (see Library Dependencies for more info).
    link_prl When this is enabled, qmake will process all libraries linked to by the application and find their meta-information (see Library Dependencies for more info).

    Please note that create_prl is required when building a static library, while link_prl is required when using a static library.

    On Windows (or if Qt is configured with -debug_and_release, adding the build_all option to the CONFIG variable makes this rule the default when building the project, and installation targets will be created for both debug and release builds.

    Additionally, adding debug_and_release to the CONFIG variable will cause both debug and release to be defined in the contents of CONFIG. When the project file is processed, the scopes that test for each value will be processed for both debug and release modes. The build_pass variable will be set for each of these mode, and you can test for this to perform build-specific tasks. For example:

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

    As a result, it may be useful to define mode-specific variables, such as QMAKE_LFLAGS_RELEASE, instead of general variables, such as QMAKE_LFLAGS, where possible.

    The following options define the application/library type:

    OptionDescription
    qt The target is a Qt application/library and requires the Qt library and header files. The proper include and library paths for the Qt library will automatically be added to the project. This is defined by default, and can be fine-tuned with the l{#qt}{QT} variable.
    thread The target is a multi-threaded application or library. The proper defines and compiler flags will automatically be added to the project.
    x11 The target is a X11 application or library. The proper include paths and libraries will automatically be added to the project.
    windows The target is a Win32 window application (app only). The proper include paths, compiler flags and libraries will automatically be added to the project.
    console The target is a Win32 console application (app only). The proper include paths, compiler flags and libraries will automatically be added to the project.
    shared The target is a shared object/DLL. The proper include paths, compiler flags and libraries will automatically be added to the project.
    dll  
    dylib  
    static The target is a static library (lib only). The proper compiler flags will automatically be added to the project.
    staticlib  
    plugin The target is a plugin (lib only). This enables dll as well.
    designer The target is a plugin for Qt Designer.
    uic3 Configures qmake to run uic3 on the content of FORMS3 if defined; otherwise the contents of FORMS will be processed instead.
    no_lflags_merge Ensures that the list of libraries stored in the LIBS variable is not reduced to a list of unique values before it is used.
    resources Configures qmake to run rcc on the content of RESOURCES if defined.

    These options are used to set the compiler flags:

    OptionDescription
    3dnow AMD 3DNow! instruction support is enabled.
    exceptions Exception support is enabled.
    mmx Intel MMX instruction support is enabled.
    rtti RTTI support is enabled.
    stl STL support is enabled.
    sse SSE support is enabled.
    sse2 SSE2 support is enabled.

    These options define specific features on Windows only:

    OptionDescription
    flat When using the vcapp template this will put all the source files into the source group and the header files into the header group regardless of what directory they reside in. Turning this option off will group the files within the source/header group depending on the directory they reside. This is turned on by default.
    embed_manifest_dll Embeds a manifest file in the DLL created as part of a library project.
    embed_manifest_exe Embeds a manifest file in the DLL created as part of an application project.
    incremental Used to enable or disable incremental linking in Visual C++, depending on whether this feature is enabled or disabled by default.

    See qmake Platform Notes for more information on the options for embedding manifest files.

    These options only have an effect on Mac OS X:

    OptionDescription
    ppc Builds a PowerPC binary.
    x86 Builds an i386 compatible binary.
    app_bundle Puts the executable into a bundle (this is the default).
    lib_bundle Puts the library into a library bundle.

    The build process for bundles is also influenced by the contents of the QMAKE_BUNDLE_DATA variable.

    These options only have an effect on the Symbian platform:

    OptionDescription
    stdbinary Builds an Open C binary (i.e. STDDLL, STDEXE, or STDLIB, depending on the target binary type.)
    no_icon Doesn't generate resources needed for displaying an icon for executable in application menu (app only).
    symbian_test Places mmp files and extension makefiles under test sections in generated bld.inf instead of their regular sections. Note that this only affects automatically generated bld.inf content; the content added via BLD_INF_RULES variable is not affected.

    These options have an effect on Linux/Unix platforms:

    OptionDescription
    largefile Includes support for large files.
    separate_debug_info Puts debugging information for libraries in separate files.

    The CONFIG variable will also be checked when resolving scopes. You may assign anything to this variable.

    For example:

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

    DEFINES

    qmake adds the values of this variable as compiler C preprocessor macros (-D option).

    For example:

     DEFINES += USE_MY_STUFF QT_DLL

    DEF_FILE

    This is only used on Windows when using the app template.

    Specifies a .def file to be included in the project.

    DEPENDPATH

    This variable contains the list of all directories to look in to resolve dependencies. This will be used when crawling through included files.

    DEPLOYMENT

    This is only used on Windows CE and the Symbian platform.

    Specifies which additional files will be deployed. Deployment means the transfer of files from the development system to the target device or emulator.

    Files can be deployed by either creating a Visual Studio project or using the cetest executable.

    For example:

     myFiles.sources = path*.png
 DEPLOYMENT += myFiles

    This will upload all PNG images in path to the same directory your build target will be deployed to.

    The default deployment target path for Windows CE is %CSIDL_PROGRAM_FILES% arget, which usually gets expanded to Program Files arget. For the Symbian platform, the default target is the application private directory on the drive it is installed to.

    It is also possible to specify multiple sources to be deployed on target paths. In addition, different variables can be used for deployment to different directories.

    For example:

     myFiles.sources = pathfile1.ext1 path2file2.ext1 path3*
 myFiles.path = somepathondevice
 someother.sources = C:additionalfiles*
 someother.path = myFilespath2
 DEPLOYMENT += myFiles someother

    Note: In Windows CE all linked Qt libraries will be deployed to the path specified by myFiles.path. On Symbian platform all libraries and executables will always be deployed to the sysin of the installation drive.

    Since the Symbian platform build system automatically moves binaries to certain directories under the epoc32 directory, custom plugins, executables or dynamically loadable libraries need special handling. When deploying extra executables or dynamically loadable libraries, the target path must specify sysin. For plugins, the target path must specify the location where the plugin stub will be deployed to (see the How to Create Qt Plugins document for more information about plugins). If the binary cannot be found from the indicated source path, the directory Symbian build process moves the executables to is searched, e.g. epoc32 eleasearmv5urel.

    For example:

     customplugin.sources = customimageplugin.dll
 customplugin.sources += c:mypluginsothercustomimageplugin.dll
 customplugin.path = imageformats
 dynamiclibrary.sources = mylib.dll helper.exe
 dynamiclibrary.path = sysin
 globalplugin.sources = someglobalimageplugin.dll
 globalplugin.path = 
esourceqtpluginsimageformats
 DEPLOYMENT += customplugin dynamiclibrary globalplugin

    On the Symbian platform, generic PKG file content can also be specified with this variable. You can use either pkg_prerules or pkg_postrules to pass raw data to PKG file. The strings in pkg_prerules are added before package-body and pkg_postrules after. The strings defined in pkg_postrules or pkg_prerules are not parsed by qmake, so they should be in a format understood by Symbian package generation tools. Please consult the Symbian platform documentation for correct syntax.

    For example, to deploy DLL and add a new dependency:

     somelib.sources = somelib.dll
 somelib.path = sysin
 somelib.pkg_prerules = "(0x12345678), 2, 2, 0, {"Some Package"}" 
                   "(0x87654321), 1, *, * ~ 2, 2, 0, {"Some Other Package"}"
 justdep.pkg_prerules = "(0xAAAABBBB), 0, 2, 0, {"My Framework"}"
 DEPLOYMENT += somelib justdep

    Please note that pkg_prerules can also replace default statements in pkg file. If no pkg_prerules is defined, qmake makes sure that PKG file syntax is correct and it contains all mandatory statements such as:

    • languages, for example 
      &EN,FR
    • package-header, for example 
      #{"MyApp-EN", "MyApp-FR"}, (0x1000001F), 1, 2, 3, TYPE=SA
    • localized and unique vendor, for example 
      %{"Vendor-EN", ..., "Vendor-FR"} :"Unique vendor name"

    If you decide to override any of these statements, you need to pay attention that also other statements stay valid. For example if you override languages statement, you must override also package-header statement and all other statements which are language specific.

    On the Symbian platform, the default_deployment item specifies default platform and package dependencies. Those dependencies can be selectively disabled if alternative dependencies need to be defined - e.g. if a specific device is required to run the application or more languages need to be supported by the package file. The supported default_deployment rules that can be disabled are:

    • pkg_depends_qt
    • pkg_depends_webkit
    • pkg_platform_dependencies

    For example:

     default_deployment.pkg_prerules -= pkg_platform_dependencies
 my_deployment.pkg_prerules = "[0x11223344],0,0,0,{"SomeSpecificDeviceID"}"
 DEPLOYMENT += my_deployment

    On the Symbian platform, you can use DEPLOYMENT.installer_header variable to generate smart installer wrapper for your application. If you specify just UID of the installer package as the value, then installer package name and version will be autogenerated:

     DEPLOYMENT.installer_header = 0x12345678

    If autogenerated values are not suitable, you can also specify the sis header yourself using this variable:

     DEPLOYMENT.installer_header = "$${LITERAL_HASH}{"My Application Installer"},(0x12345678),1,0,0"

    DEPLOYMENT_PLUGIN

    This is only used on Windows CE and the Symbian platform.

    This variable specifies the Qt plugins that will be deployed. All plugins available in Qt can be explicitly deployed to the device. See Static Plugins for a complete list.

    Note: In Windows CE, No plugins will be deployed automatically. If the application depends on plugins, these plugins have to be specified manually.

    Note: On the Symbian platform, all plugins supported by this variable will be deployed by default with Qt libraries, so generally using this variable is not needed.

    For example:

     DEPLOYMENT_PLUGIN += qjpeg

    This will upload the jpeg imageformat plugin to the plugins directory on the Windows CE device.

    DESTDIR

    Specifies where to put the target file.

    For example:

     DESTDIR = ../../lib

    DESTDIR_TARGET

    This variable is set internally by qmake, which is basically the DESTDIR variable with the TARGET variable appened at the end. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    DLLDESTDIR

    Specifies where to copy the target dll.

    DISTFILES

    This variable contains a list of files to be included in the dist target. This feature is supported by UnixMake specs only.

    For example:

     DISTFILES += ../program.txt

    DSP_TEMPLATE

    This variable is set internally by qmake, which specifies where the dsp template file for basing generated dsp files is stored. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    FORMS

    This variable specifies the UI files (see Qt Designer) to be processed through uic before compiling. All dependencies, headers and source files required to build these UI files will automatically be added to the project.

    For example:

     FORMS = mydialog.ui 
     mywidget.ui 
         myconfig.ui

    If FORMS3 is defined in your project, then this variable must contain forms for uic, and not uic3. If CONFIG contains uic3, and FORMS3 is not defined, the this variable must contain only uic3 type forms.

    FORMS3

    This variable specifies the old style UI files to be processed through uic3 before compiling, when CONFIG contains uic3. All dependencies, headers and source files required to build these UI files will automatically be added to the project.

    For example:

     FORMS3 = my_uic3_dialog.ui 
      my_uic3_widget.ui 
          my_uic3_config.ui

    GUID

    Specifies the GUID that is set inside a .vcproj file. The GUID is usually randomly determined. However, should you require a fixed GUID, it can be set using this variable.

    This variable is specific to .vcproj files only; it is ignored otherwise.

    HEADERS

    Defines the header files for the project.

    qmake will generate dependency information (unless -nodepend is specified on the command line) for the specified headers. qmake will also automatically detect if moc is required by the classes in these headers, and add the appropriate dependencies and files to the project for generating and linking the moc files.

    For example:

     HEADERS = myclass.h 
           login.h 
           mainwindow.h

    See also SOURCES.

    ICON

    This variable is used only in MAC and the Symbian platform to set the application icon. Please see the application icon documentation for more information.

    INCLUDEPATH

    This variable specifies the #include directories which should be searched when compiling the project. Use ';' or a space as the directory separator.

    For example:

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

    To specify a path containing spaces, quote the path using the technique mentioned in the qmake Project Files document. For example, paths with spaces can be specified on Windows and Unix platforms by using the quote() function in the following way:

     win32:INCLUDEPATH += $$quote(C:/mylibs/extra headers)
 unix:INCLUDEPATH += $$quote(/home/user/extra headers)

    INSTALLS

    This variable contains a list of resources that will be installed when make install or a similar installation procedure is executed. Each item in the list is typically defined with attributes that provide information about where it will be installed.

    For example, the following target.path definition describes where the build target will be installed, and the INSTALLS assignment adds the build target to the list of existing resources to be installed:

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

    LEXIMPLS

    This variable contains a list of lex implementation files. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    LEXOBJECTS

    This variable contains the names of intermediate lex object files.The value of this variable is typically handled by qmake and rarely needs to be modified.

    LEXSOURCES

    This variable contains a list of lex source files. All dependencies, headers and source files will automatically be added to the project for building these lex files.

    For example:

     LEXSOURCES = lexer.l

    LIBS

    This variable contains a list of libraries to be linked into the project. You can use the Unix -l (library) and -L (library path) flags and qmake will do the correct thing with these libraries on Windows and the Symbian platform (namely this means passing the full path of the library to the linker). The only limitation to this is the library must exist, for qmake to find which directory a -l lib lives in.

    For example:

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

    To specify a path containing spaces, quote the path using the technique mentioned in the qmake Project Files document. For example, paths with spaces can be specified on Windows and Unix platforms by using the quote() function in the following way:

     win32:LIBS += $$quote(C:/mylibs/extra libs/extra.lib)
 unix:LIBS += $$quote(-L/home/user/extra libs) -lextra

    Note: On Windows, specifying libraries with the -l option, as in the above example, will cause the library with the highest version number to be used; for example,libmath2.lib could potentially be used instead of libmathlib. To avoid this ambiguity, we recommend that you explicitly specify the library to be used by including the .lib file name suffix.

    Note: On the Symbian platform, the build system makes a distinction between shared and static libraries. In most cases, qmake will figure out which library you are refering to, but in some cases you may have to specify it explicitly to get the expected behavior. This typically happens if you are building a library and using it in the same project. To specify that the library is either shared or static, add a ".dll" or ".lib" suffix, respectively, to the library name.

    By default, the list of libraries stored in LIBS is reduced to a list of unique names before it is used. To change this behavior, add the no_lflags_merge option to the CONFIGvariable:

     CONFIG += no_lflags_merge

    LITERAL_HASH

    This variable is used whenever a literal hash character (#) is needed in a variable declaration, perhaps as part of a file name or in a string passed to some external application.

    For example:

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

    By using LITERAL_HASH in this way, the # character can be used to construct a URL for the message() function to print to the console.

    MAKEFILE

    This variable specifies the name of the Makefile which qmake should use when outputting the dependency information for building a project. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    MAKEFILE_GENERATOR

    This variable contains the name of the Makefile generator to use when generating a Makefile. The value of this variable is typically handled internally by qmake and rarely needs to be modified.

    MMP_RULES

    This is only used on the Symbian platform.

    Generic MMP file content can be specified with this variable.

    For example:

     MMP_RULES += "DEFFILE hello.def"

    This will add the specified statement to the end of the generated MMP file.

    It is also possible to add multiple rows in a single block. Each double quoted string will be placed on a new row in the generated MMP file.

    For example:

     myBlock = 
 "START RESOURCE foo.rss" 
 "TARGET bar" 
 "TARGETPATH private10001234" 
 "HEADER" 
 "LANG 01" 
 "UID 0x10002345 0x10003456" 
 "END"

 MMP_RULES += myBlock

    If you need to include a hash (#) character inside the MMP_RULES statement, it can be done with the variable LITERAL_HASH as follows:

     myIfdefBlock = 
 "$${LITERAL_HASH}ifdef WINSCW" 
 "DEFFILE hello_winscw.def" 
 "$${LITERAL_HASH}endif"

 MMP_RULES += myIfdefBlock

    There is also a convenience function for adding conditional rules called addMMPRules. Suppose you need certain functionality to require different library depending on architecture. This can be specified with addMMPRules as follows:

     # Set conditional libraries
 LIB.MARM = "LIBRARY myarm.lib"
 LIB.WINSCW = "LIBRARY mywinscw.lib"
 LIB.default = "LIBRARY mydefault.lib"

 # Add the conditional MMP rules
 MYCONDITIONS = MARM WINSCW
 MYVARIABLES = LIB

 addMMPRules(MYCONDITIONS, MYVARIABLES)

    Note: You should not use this variable to add MMP statements that are explicitly supported by their own variables, such as TARGET.EPOCSTACKSIZE. Doing so could result in duplicate statements in the MMP file.

    MOC_DIR

    This variable specifies the directory where all intermediate moc files should be placed.

    For example:

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

    OBJECTS

    This variable is generated from the SOURCES variable. The extension of each source file will have been replaced by .o (Unix) or .obj (Win32). The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    OBJECTS_DIR

    This variable specifies the directory where all intermediate objects should be placed.

    For example:

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

    OBJMOC

    This variable is set by qmake if files can be found that contain the Q_OBJECT macro. OBJMOC contains the name of all intermediate moc object files. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    POST_TARGETDEPS

    All libraries that the target depends on can be listed in this variable. Some backends do not support this, these include MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is supported internally by these build tools, this is useful for explicitly listing dependant static libraries.

    This list will go after all builtin (and $$PRE_TARGETDEPS) dependencies.

    PRE_TARGETDEPS

    All libraries that the target depends on can be listed in this variable. Some backends do not support this, these include MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is supported internally by these build tools, this is useful for explicitly listing dependant static libraries.

    This list will go before all builtin dependencies.

    PRECOMPILED_HEADER

    This variable indicates the header file for creating a precompiled header file, to increase the compilation speed of a project. Precompiled headers are currently only supported on some platforms (Windows - all MSVC project types, Mac OS X - Xcode, Makefile, Unix - gcc 3.3 and up).

    On other platforms, this variable has different meaning, as noted below.

    This variable contains a list of header files that require some sort of pre-compilation step (such as with moc). The value of this variable is typically handled by qmake orqmake.conf and rarely needs to be modified.

    PWD

    This variable contains the full path leading to the directory where the qmake project file (project.pro) is located.

    OUT_PWD

    This variable contains the full path leading to the directory where qmake places the generated Makefile.

    QMAKE

    This variable contains the name of the qmake program itself and is placed in generated Makefiles. The value of this variable is typically handled by qmake or qmake.confand rarely needs to be modified.

    QMAKESPEC

    This variable contains the name of the qmake configuration to use when generating Makefiles. The value of this variable is typically handled by qmake and rarely needs to be modified.

    Use the QMAKESPEC environment variable to override the qmake configuration. Note that, due to the way qmake reads project files, setting the QMAKESPEC environment variable from within a project file will have no effect.

    QMAKE_APP_FLAG

    This variable is empty unless the app TEMPLATE is specified. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified. Use the following instead:

     app {
     # Conditional code for 'app' template here
 }

    QMAKE_APP_OR_DLL

    This variable is empty unless the app or dll TEMPLATE is specified. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_AR_CMD

    This is used on Unix platforms only.

    This variable contains the command for invoking the program which creates, modifies and extracts archives. The value of this variable is typically handled by qmake orqmake.conf and rarely needs to be modified.

    QMAKE_BUNDLE_DATA

    This variable is used to hold the data that will be installed with a library bundle, and is often used to specify a collection of header files.

    For example, the following lines add path/to/header_one.h and path/to/header_two.h to a group containing information about the headers supplied with the framework:

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

    The last line adds the information about the headers to the collection of resources that will be installed with the library bundle.

    Library bundles are created when the lib_bundle option is added to the CONFIG variable.

    See qmake Platform Notes for more information about creating library bundles.

    This is used on Mac OS X only.

    QMAKE_BUNDLE_EXTENSION

    This variable defines the extension to be used for library bundles. This allows frameworks to be created with custom extensions instead of the standard .frameworkdirectory name extension.

    For example, the following definition will result in a framework with the .myframework extension:

     QMAKE_BUNDLE_EXTENSION = .myframework

    This is used on Mac OS X only.

    QMAKE_CC

    This variable specifies the C compiler that will be used when building projects containing C source code. Only the file name of the compiler executable needs to be specified as long as it is on a path contained in the PATH variable when the Makefile is processed.

    QMAKE_CFLAGS_DEBUG

    This variable contains the flags for the C compiler in debug mode.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_MT

    This variable contains the compiler flags for creating a multi-threaded application or when the version of Qt that you link against is a multi-threaded statically linked library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_MT_DBG

    This variable contains the compiler flags for creating a debuggable multi-threaded application or when the version of Qt that you link against is a debuggable multi-threaded statically linked library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_MT_DLL

    This is used on Windows only.

    This variable contains the compiler flags for creating a multi-threaded dll or when the version of Qt that you link against is a multi-threaded dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_MT_DLLDBG

    This is used on Windows only.

    This variable contains the compiler flags for creating a debuggable multi-threaded dll or when the version of Qt that you link against is a debuggable multi-threaded statically linked library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_RELEASE

    This variable contains the compiler flags for creating a non-debuggable application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_SHLIB

    This is used on Unix platforms only.

    This variable contains the compiler flags for creating a shared library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_THREAD

    This variable contains the compiler flags for creating a multi-threaded application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_WARN_OFF

    This variable is not empty if the warn_off TEMPLATE option is specified. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CFLAGS_WARN_ON

    This variable is not empty if the warn_on TEMPLATE option is specified. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CLEAN

    This variable contains any files which are not generated files (such as moc and uic generated files) and object files that should be removed when using "make clean".

    QMAKE_CXX

    This variable specifies the C++ compiler that will be used when building projects containing C++ source code. Only the file name of the compiler executable needs to be specified as long as it is on a path contained in the PATH variable when the Makefile is processed.

    QMAKE_CXXFLAGS

    This variable contains the C++ compiler flags that are used when building a project. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified. The flags specific to debug and release modes can be adjusted by modifying the QMAKE_CXXFLAGS_DEBUG and QMAKE_CXXFLAGS_RELEASEvariables, respectively.

    Note: On the Symbian platform, this variable can be used to pass architecture specific options to each compiler in the Symbian build system. For example:

     QMAKE_CXXFLAGS.CW += -O2
 QMAKE_CXXFLAGS.ARMCC += -O0

    For more information, see qmake Platform Notes.

    QMAKE_CXXFLAGS_DEBUG

    This variable contains the C++ compiler flags for creating a debuggable application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_MT

    This variable contains the C++ compiler flags for creating a multi-threaded application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_MT_DBG

    This variable contains the C++ compiler flags for creating a debuggable multi-threaded application. The value of this variable is typically handled by qmake orqmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_MT_DLL

    This is used on Windows only.

    This variable contains the C++ compiler flags for creating a multi-threaded dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_MT_DLLDBG

    This is used on Windows only.

    This variable contains the C++ compiler flags for creating a multi-threaded debuggable dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_RELEASE

    This variable contains the C++ compiler flags for creating an application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_SHLIB

    This variable contains the C++ compiler flags for creating a shared library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_THREAD

    This variable contains the C++ compiler flags for creating a multi-threaded application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_WARN_OFF

    This variable contains the C++ compiler flags for suppressing compiler warnings. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_CXXFLAGS_WARN_ON

    This variable contains C++ compiler flags for generating compiler warnings. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_DISTCLEAN

    This variable removes extra files upon the invocation of make distclean.

    QMAKE_EXTENSION_SHLIB

    This variable contains the extention for shared libraries. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    Note that platform-specific variables that change the extension will override the contents of this variable.

    QMAKE_EXT_MOC

    This variable changes the extention used on included moc files.

    See also File Extensions.

    QMAKE_EXT_UI

    This variable changes the extention used on /e Designer UI files.

    See also File Extensions.

    QMAKE_EXT_PRL

    This variable changes the extention used on created PRL files.

    See also File Extensions, Library Dependencies.

    QMAKE_EXT_LEX

    This variable changes the extention used on files given to lex.

    See also File Extensions, LEXSOURCES.

    QMAKE_EXT_YACC

    This variable changes the extention used on files given to yacc.

    See also File Extensions, YACCSOURCES.

    QMAKE_EXT_OBJ

    This variable changes the extention used on generated object files.

    See also File Extensions.

    QMAKE_EXT_CPP

    This variable changes the interpretation of all suffixes in this list of values as files of type C++ source code.

    See also File Extensions.

    QMAKE_EXT_H

    This variable changes the interpretation of all suffixes in this list of values as files of type C header files.

    See also File Extensions.

    QMAKE_EXTRA_COMPILERS

    This variable contains the extra compilers/preprocessors that have been added

    See also Customizing Makefile Output

    QMAKE_EXTRA_TARGETS

    This variable contains the extra targets that have been added

    See also Customizing Makefile Output

    QMAKE_FAILED_REQUIREMENTS

    This variable contains the list of requirements that were failed to be met when qmake was used. For example, the sql module is needed and wasn't compiled into Qt. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_FILETAGS

    This variable contains the file tags needed to be entered into the Makefile, such as SOURCES and HEADERS. The value of this variable is typically handled by qmakeor qmake.conf and rarely needs to be modified.

    QMAKE_FRAMEWORK_BUNDLE_NAME

    In a framework project, this variable contains the name to be used for the framework that is built.

    By default, this variable contains the same value as the TARGET variable.

    See qmake Platform Notes for more information about creating frameworks and library bundles.

    This is used on Mac OS X only.

    QMAKE_FRAMEWORK_VERSION

    For projects where the build target is a Mac OS X framework, this variable is used to specify the version number that will be applied to the framework that is built.

    By default, this variable contains the same value as the VERSION variable.

    See qmake Platform Notes for more information about creating frameworks.

    This is used on Mac OS X only.

    QMAKE_INCDIR

    This variable contains the location of all known header files to be added to INCLUDEPATH when building an application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_INCDIR_EGL

    This variable contains the location of EGL header files to be added to INCLUDEPATH when building an application with OpenGL/ES or OpenVG support. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_INCDIR_OPENGL

    This variable contains the location of OpenGL header files to be added to INCLUDEPATH when building an application with OpenGL support. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenGL implementation uses EGL (most OpenGL/ES systems), then QMAKE_INCDIR_EGL may also need to be set.

    QMAKE_INCDIR_OPENGL_ES1, QMAKE_INCDIR_OPENGL_ES1CL, QMAKE_INCDIR_OPENGL_ES2

    These variables contain the location of OpenGL headers files to be added to INCLUDEPATH when building an application with OpenGL ES 1, OpenGL ES 1 Common Lite or OpenGL ES 2 support respectively.

    The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenGL implementation uses EGL (most OpenGL/ES systems), then QMAKE_INCDIR_EGL may also need to be set.

    QMAKE_INCDIR_OPENVG

    This variable contains the location of OpenVG header files to be added to INCLUDEPATH when building an application with OpenVG support. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenVG implementation uses EGL then QMAKE_INCDIR_EGL may also need to be set.

    QMAKE_INCDIR_QT

    This variable contains the location of all known header file paths to be added to INCLUDEPATH when building a Qt application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_INCDIR_THREAD

    This variable contains the location of all known header file paths to be added to INCLUDEPATH when building a multi-threaded application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_INCDIR_X11

    This is used on Unix platforms only.

    This variable contains the location of X11 header file paths to be added to INCLUDEPATH when building a X11 application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_INFO_PLIST

    This is used on Mac OS X platforms only.

    This variable contains the name of the property list file, .plist, you would like to include in your Mac OS X application bundle.

    In the .plist file, you can define some variables, e.g., @EXECUTABLE@, which qmake will replace with the actual executable name. Other variables include @ICON@, @TYPEINFO@, @LIBRARY@, and @SHORT_VERSION@.

    Note: Most of the time, the default Info.plist is good enough.

    QMAKE_LFLAGS

    This variable contains a general set of flags that are passed to the linker. If you need to change the flags used for a particular platform or type of project, use one of the specialized variables for that purpose instead of this variable.

    QMAKE_LFLAGS_CONSOLE

    This is used on Windows only.

    This variable contains link flags when building console programs. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_CONSOLE_DLL

    This is used on Windows only.

    This variable contains link flags when building console dlls. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_DEBUG

    This variable contains link flags when building debuggable applications. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_PLUGIN

    This variable contains link flags when building plugins. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_RPATH

    This is used on Unix platforms only.

    Library paths in this definition are added to the executable at link time so that the added paths will be preferentially searched at runtime.

    QMAKE_LFLAGS_QT_DLL

    This variable contains link flags when building programs that use the Qt library built as a dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_RELEASE

    This variable contains link flags when building applications for release. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_SHAPP

    This variable contains link flags when building applications which are using the app template. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_SHLIB

    This variable contains link flags when building shared libraries The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_SONAME

    This variable specifies the link flags to set the name of shared objects, such as .so or .dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_THREAD

    This variable contains link flags when building multi-threaded projects. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_WINDOWS

    This is used on Windows only.

    This variable contains link flags when building Windows GUI projects (i.e. non-console applications). The value of this variable is typically handled by qmake orqmake.conf and rarely needs to be modified.

    QMAKE_LFLAGS_WINDOWS_DLL

    This is used on Windows only.

    This variable contains link flags when building Windows DLL projects. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBDIR

    This variable contains the location of all known library directories.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBDIR_FLAGS

    This is used on Unix platforms only.

    This variable contains the location of all library directory with -L prefixed. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBDIR_EGL

    This variable contains the location of the EGL library directory, when EGL is used with OpenGL/ES or OpenVG. The value of this variable is typically handled by qmakeor qmake.conf and rarely needs to be modified.

    QMAKE_LIBDIR_OPENGL

    This variable contains the location of the OpenGL library directory.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenGL implementation uses EGL (most OpenGL/ES systems), then QMAKE_LIBDIR_EGL may also need to be set.

    QMAKE_LIBDIR_OPENVG

    This variable contains the location of the OpenVG library directory. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenVG implementation uses EGL, then QMAKE_LIBDIR_EGL may also need to be set.

    QMAKE_LIBDIR_QT

    This variable contains the location of the Qt library directory.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBDIR_X11

    This is used on Unix platforms only.

    This variable contains the location of the X11 library directory.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS

    This variable contains all project libraries. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_CONSOLE

    This Windows-specific variable is no longer used.

    Prior to Qt 4.2, this variable was used to list the libraries that should be linked against when building a console application project on Windows. QMAKE_LIBS_WINDOWshould now be used instead.

    QMAKE_LIBS_EGL

    This variable contains all EGL libraries when building Qt with OpenGL/ES or OpenVG. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified. The usual value is -lEGL.

    QMAKE_LIBS_OPENGL

    This variable contains all OpenGL libraries. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenGL implementation uses EGL (most OpenGL/ES systems), then QMAKE_LIBS_EGL may also need to be set.

    QMAKE_LIBS_OPENGL_QT

    This variable contains all OpenGL Qt libraries.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_OPENGL_ES1, QMAKE_LIBS_OPENGL_ES1CL, QMAKE_LIBS_OPENGL_ES2

    These variables contain all the OpenGL libraries for OpenGL ES 1, OpenGL ES 1 Common Lite profile and OpenGL ES 2.

    The value of these variables is typically handled by qmake or qmake.conf and rarely needs to be modified.

    If the OpenGL implementation uses EGL (most OpenGL/ES systems), then QMAKE_LIBS_EGL may also need to be set.

    QMAKE_LIBS_OPENVG

    This variable contains all OpenVG libraries. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified. The usual value is -lOpenVG.

    Some OpenVG engines are implemented on top of OpenGL. This will be detected at configure time and QMAKE_LIBS_OPENGL will be implicitly added toQMAKE_LIBS_OPENVG wherever the OpenVG libraries are linked.

    If the OpenVG implementation uses EGL, then QMAKE_LIBS_EGL may also need to be set.

    QMAKE_LIBS_QT

    This variable contains all Qt libraries.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_QT_DLL

    This is used on Windows only.

    This variable contains all Qt libraries when Qt is built as a dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_QT_OPENGL

    This variable contains all the libraries needed to link against if OpenGL support is turned on. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_QT_THREAD

    This variable contains all the libraries needed to link against if thread support is turned on. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_RT

    This is used with Borland compilers only.

    This variable contains the runtime library needed to link against when building an application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_RTMT

    This is used with Borland compilers only.

    This variable contains the runtime library needed to link against when building a multi-threaded application. The value of this variable is typically handled by qmake orqmake.conf and rarely needs to be modified.

    QMAKE_LIBS_THREAD

    This is used on Unix platforms only.

    This variable contains all libraries that need to be linked against when building a multi-threaded application. The value of this variable is typically handled by qmake orqmake.conf and rarely needs to be modified.

    QMAKE_LIBS_WINDOWS

    This is used on Windows only.

    This variable contains all windows libraries.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_X11

    This is used on Unix platforms only.

    This variable contains all X11 libraries.The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIBS_X11SM

    This is used on Unix platforms only.

    This variable contains all X11 session management libraries. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LIB_FLAG

    This variable is not empty if the lib template is specified. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_LINK_SHLIB_CMD

    This variable contains the command to execute when creating a shared library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_POST_LINK

    This variable contains the command to execute after linking the TARGET together. This variable is normally empty and therefore nothing is executed, additionally some backends will not support this - mostly only Makefile backends.

    QMAKE_PRE_LINK

    This variable contains the command to execute before linking the TARGET together. This variable is normally empty and therefore nothing is executed, additionally some backends will not support this - mostly only Makefile backends.

    QMAKE_LN_SHLIB

    This variable contains the command to execute when creating a link to a shared library. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_MAC_SDK

    This variable is used on Mac OS X when building universal binaries. This process is described in more detail in the Deploying an Application on Mac OS X document.

    QMAKE_MACOSX_DEPLOYMENT_TARGET

    This variable only has an effect when building on Mac OS X. On that platform, the variable will be forwarded to the MACOSX_DEPLOYMENT_TARGET environment variable, which is interpreted by the compiler or linker. For more information, see the Deploying an Application on Mac OS X document.

    QMAKE_MAKEFILE

    This variable contains the name of the Makefile to create. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_MOC_SRC

    This variable contains the names of all moc source files to generate and include in the project. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_QMAKE

    This variable contains the location of qmake if it is not in the path. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_QT_DLL

    This variable is not empty if Qt was built as a dll. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_RESOURCE_FLAGS

    This variable is used to customize the list of options passed to the Resource Compiler in each of the build rules where it is used. For example, the following line ensures that the -threshold and -compress options are used with particular values each time that rcc is invoked:

     QMAKE_RESOURCE_FLAGS += -threshold 0 -compress 9

    QMAKE_RPATH

    This is used on Unix platforms only.

    Is equivalent to QMAKE_LFLAGS_RPATH.

    QMAKE_RPATHDIR

    This is used on Unix platforms only.

    A list of library directory paths, these paths are added to the executable at link time so that the paths will be preferentially searched at runtime.

    QMAKE_RUN_CC

    This variable specifies the individual rule needed to build an object. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_RUN_CC_IMP

    This variable specifies the individual rule needed to build an object. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_RUN_CXX

    This variable specifies the individual rule needed to build an object. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_RUN_CXX_IMP

    This variable specifies the individual rule needed to build an object. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_TARGET

    This variable contains the name of the project target. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    QMAKE_UIC

    This variable contains the location of uic if it is not in the path. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    It can be used to specify arguments to uic as well, such as additional plugin paths. For example:

     QMAKE_UIC = uic -L /path/to/plugin

    QT

    The values stored in the QT variable control which of the Qt modules are used by your project.

    The table below shows the options that can be used with the QT variable and the features that are associated with each of them:

    OptionFeatures
    core (included by default) QtCore module
    gui (included by default) QtGui module
    network QtNetwork module
    opengl QtOpenGL module
    phonon Phonon Multimedia Framework
    sql QtSql module
    svg QtSvg module
    xml QtXml module
    webkit WebKit integration
    qt3support Qt3Support module

    By default, QT contains both core and gui, ensuring that standard GUI applications can be built without further configuration.

    If you want to build a project without the QtGui module, you need to exclude the gui value with the "-=" operator; the following line will result in a minimal Qt project being built:

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

    Note that adding the opengl option to the QT variable automatically causes the equivalent option to be added to the CONFIG variable. Therefore, for Qt applications, it is not necessary to add the opengl option to both CONFIG and QT.

    QTPLUGIN

    This variable contains a list of names of static plugins that are to be compiled with an application so that they are available as built-in resources.

    QT_VERSION

    This variable contains the current version of Qt.

    QT_MAJOR_VERSION

    This variable contains the current major version of Qt.

    QT_MINOR_VERSION

    This variable contains the current minor version of Qt.

    QT_PATCH_VERSION

    This variable contains the current patch version of Qt.

    RC_FILE

    This variable contains the name of the resource file for the application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    RCC_DIR

    This variable specifies the directory where all intermediate resource files should be placed.

    For example:

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

    REQUIRES

    This is a special variable processed by qmake. If the contents of this variable do not appear in CONFIG by the time this variable is assigned, then a minimal Makefile will be generated that states what dependencies (the values assigned to REQUIRES) are missing.

    This is mainly used in Qt's build system for building the examples.

    RESOURCES

    This variable contains the name of the resource collection file (qrc) for the application. Further information about the resource collection file can be found at The Qt Resource System.

    RES_FILE

    This variable contains the name of the resource file for the application. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    RSS_RULES

    This is only used on the Symbian platform.

    Generic RSS file content can be specified with this variable. The syntax is similar to MMP_RULES and BLD_INF_RULES.

    For example:

     RSS_RULES += "hidden = KAppIsHidden;"

    This will add the specified statement to the end of the APP_REGISTRATION_INFO resource struct in the generated registration resource file. As an impact of this statement, the application will not be visible in application shell.

    It is also possible to add multiple rows in a single block. Each double quoted string will be placed on a new row in the registration resource file.

    For example:

     myrssrules = 
     "hidden = KAppIsHidden;" 
     "launch = KAppLaunchInBackground;" 
 RSS_RULES += myrssrules

    This example will install the application to MyFolder in the Symbian platform application shell. In addition it will make the application to be launched in background.

    For detailed list of possible APP_REGISTRATION_INFO statements, please refer to the Symbian platform help.

    Note: You should not use RSS_RULES variable to set the following RSS statements: app_file, localisable_resource_file, and localisable_resource_id.

    These statements are internally handled by qmake.

    There is a number of special modifiers you can attach to RSS_RULES to specify where in the application registration file the rule will be written:

    ModifierLocation of the rule
    <no modifier> Inside APP_REGISTRATION_INFO resource struct.
    .header Before APP_REGISTRATION_INFO resource struct.
    .footer After APP_REGISTRATION_INFO resource struct.
    .service_list Inside a SERVICE_INFO item in the service_list of APP_REGISTRATION_INFO
    .file_ownership_list Inside a FILE_OWNERSHIP_INFO item in the file_ownership_list of APP_REGISTRATION_INFO
    .datatype_list Inside a DATATYPE item in the datatype_list of APP_REGISTRATION_INFO

    For example:

     RSS_RULES.service_list += "uid = 0x12345678; datatype_list = {}; opaque_data = r_my_icon;"
 RSS_RULES.footer +="RESOURCE CAPTION_AND_ICON_INFO r_my_icon { icon_file ="$$PWD/my_icon.svg"; }"

    This example will define service information for a fictional service that requires an icon to be supplied via the opaque_data of the service information.

    S60_VERSION

    This is only used on the Symbian platform.

    Contains the version number of the underlying S60 SDK; e.g. "5.0".

    SIGNATURE_FILE

    This is only used on Windows CE.

    Specifies which signature file should be used to sign the project target.

    Note: This variable will overwrite the setting you have specified in configure, with the -signature option.

    SOURCES

    This variable contains the name of all source files in the project.

    For example:

     SOURCES = myclass.cpp 
       login.cpp 
       mainwindow.cpp

    See also HEADERS

    SRCMOC

    This variable is set by qmake if files can be found that contain the Q_OBJECT macro. SRCMOC contains the name of all the generated moc files. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    SUBDIRS

    This variable, when used with the subdirs template contains the names of all subdirectories that contain parts of the project that need be built. Each subdirectory must contain its own project file.

    For example:

     SUBDIRS = kernel 
           tools

    It is essential that the project file in each subdirectory has the same name as the subdirectory itself, so that qmake can find it. For example, if the subdirectory is calledmyapp then the project file in that directory should be called myapp.pro.

    If you need to ensure that the subdirectories are built in the order in which they are specified, update the CONFIG variable to include the ordered option:

     CONFIG += ordered

    It is possible to modify this default behavior of SUBDIRS by giving additional modifiers to SUBDIRS elements. Supported modifiers are:

    ModifierEffect
    .subdir Use the specified subdirectory instead of SUBDIRS value.
    .file Specify the subproject pro file explicitly. Cannot be used in conjunction with .subdir modifier.
    .condition Specifies a bld.inf define that must be true for subproject to be built. Available only on Symbian platform.
    .depends This subproject depends on specified subproject. Available only on platforms that use makefiles.
    .makefile The makefile of subproject. Available only on platforms that use makefiles.
    .target Base string used for makefile targets related to this subproject. Available only on platforms that use makefiles.

    For example, define two subdirectories, both of which reside in a different directory than the SUBDIRS value, and one of the subdirectories must be built before the other:

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

    For example, define a subdirectory that is only build for emulator builds in Qt for Symbian:

     symbian {
     SUBDIRS += emulator_dll
     emulator_dll.condition = WINSCW
 }

    TARGET

    This specifies the name of the target file.

    For example:

     TEMPLATE = app
 TARGET = myapp
 SOURCES = main.cpp

    The project file above would produce an executable named myapp on unix and 'myapp.exe' on windows.

    TARGET.CAPABILITY

    This is only used on the Symbian platform.

    Specifies which platform capabilities the application should have. For more information, please refer to the Symbian SDK documentation.

    TARGET.EPOCALLOWDLLDATA

    This is only used on the Symbian platform.

    Specifies whether static data should be allowed in the application. Symbian disallows this by default in order to save memory. To use it, set this to 1.

    TARGET.EPOCHEAPSIZE

    This is only used on the Symbian platform.

    Specifies the minimum and maximum heap size of the application. The program will refuse to run if the minimum size is not available when it starts. For example:

     TARGET.EPOCHEAPSIZE = 10000 10000000

    TARGET.EPOCSTACKSIZE

    This is only used on the Symbian platform.

    Specifies the maximum stack size of the application. For example:

     TARGET.EPOCSTACKSIZE = 0x8000

    TARGET.SID

    This is only used on the Symbian platform.

    Specifies which secure identifier to use for the target application or library. For more information, see the Symbian SDK documentation.

    TARGET.UID2

    This is only used on the Symbian platform.

    Specifies which unique identifier 2 to use for the target application or library. If this variable is not specified, it defaults to the same value as TARGET.UID3. For more information, see the Symbian SDK documentation.

    TARGET.UID3

    This is only used on the Symbian platform.

    Specifies which unique identifier 3 to use for the target application or library. If this variable is not specified, a UID3 suitable for development and debugging will be generated automatically. However, applications being released should always define this variable. For more information, see the Symbian SDK documentation.

    TARGET.VID

    This is only used on the Symbian platform.

    Specifies which vendor identifier to use for the target application or library. For more information, see the Symbian SDK documentation.

    TARGET_EXT

    This variable specifies the target's extension. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    TARGET_x

    This variable specifies the target's extension with a major version number. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    TARGET_x.y.z

    This variable specifies the target's extension with version number. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    TEMPLATE

    This variable contains the name of the template to use when generating the project. The allowed values are:

    OptionDescription
    app Creates a Makefile for building applications (the default). (See qmake Common Projects for more information.)
    lib Creates a Makefile for building libraries. (See qmake Common Projects for more information.)
    subdirs Creates a Makefile for building targets in subdirectories. The subdirectories are specified using the SUBDIRS variable.
    vcapp Windows only Creates an application project for Visual Studio. (See qmake Platform Notes for more information.)
    vclib Windows only Creates a library project for Visual Studio. (See qmake Platform Notes for more information.)

    For example:

     TEMPLATE = lib
 SOURCES = main.cpp
 TARGET = mylib

    The template can be overridden by specifying a new template type with the -t command line option. This overrides the template type after the .pro file has been processed. With .pro files that use the template type to determine how the project is built, it is necessary to declare TEMPLATE on the command line rather than use the-t option.

    TRANSLATIONS

    This variable contains a list of translation (.ts) files that contain translations of the user interface text into non-native languages.

    See the Qt Linguist Manual for more information about internationalization (i18n) and localization (l10n) with Qt.

    UICIMPLS

    This variable contains a list of the generated implementation files by UIC. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    UICOBJECTS

    This variable is generated from the UICIMPLS variable. The extension of each file will have been replaced by .o (Unix) or .obj (Win32). The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    UI_DIR

    This variable specifies the directory where all intermediate files from uic should be placed. This variable overrides both UI_SOURCES_DIR and UI_HEADERS_DIR.

    For example:

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

    UI_HEADERS_DIR

    This variable specifies the directory where all declaration files (as generated by uic) should be placed.

    For example:

     unix:UI_HEADERS_DIR = ../myproject/ui/include
 win32:UI_HEADERS_DIR = c:/myproject/ui/include

    UI_SOURCES_DIR

    This variable specifies the directory where all implementation files (as generated by uic) should be placed.

    For example:

     unix:UI_SOURCES_DIR = ../myproject/ui/src
 win32:UI_SOURCES_DIR = c:/myproject/ui/src

    VERSION

    This variable contains the version number of the application or library if either the app TEMPLATE or the lib TEMPLATE is specified.

    For example:

     VERSION = 1.2.3

    VER_MAJ

    This variable contains the major version number of the library, if the lib template is specified.

    VER_MIN

    This variable contains the minor version number of the library, if the lib template is specified.

    VER_PAT

    This variable contains the patch version number of the library, if the lib template is specified.

    VPATH

    This variable tells qmake where to search for files it cannot open. With this you may tell qmake where it may look for things like SOURCES, and if it finds an entry in SOURCES that cannot be opened it will look through the entire VPATH list to see if it can find the file on its own.

    See also DEPENDPATH.

    YACCIMPLS

    This variable contains a list of yacc source files. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    YACCOBJECTS

    This variable contains a list of yacc object files. The value of this variable is typically handled by qmake or qmake.conf and rarely needs to be modified.

    YACCSOURCES

    This variable contains a list of yacc source files to be included in the project. All dependencies, headers and source files will automatically be included in the project.

    For example:

     YACCSOURCES = moc.y

    _PRO_FILE_

    This variable contains the path to the project file in use.

    For example, the following line causes the location of the project file to be written to the console:

     message($$_PRO_FILE_)

    _PRO_FILE_PWD_

    This variable contains the path to the directory containing the project file in use.

    For example, the following line causes the location of the directory containing the project file to be written to the console:

     message($$_PRO_FILE_PWD_)

    [Previous: qmake Reference] [Contents] [Next: qmake Function Reference]

    ======================= End
  • 相关阅读:
    你认为做好测试计划工作的关键是什么？
    一套完整的测试应该由哪些阶段组成？
    你对测试最大的兴趣在哪里？为什么？
    如何测试一个纸杯？
    黑盒测试和白盒测试各自的优缺点
    在您以往的工作中，一条软件缺陷（或者叫Bug）记录都包含了哪些内容？如何提交高质量的软件缺陷（Bug）记录？
    测试人员在软件开发过程中的任务
    软件测试分为几个阶段？ 各阶段的测试策略和要求是什么?
    软件测试的策略
    软件产品质量特性
  • 原文地址：https://www.cnblogs.com/lsgxeva/p/12161178.html
Copyright © 2011-2022 走看看