summaryrefslogtreecommitdiffstats
path: root/experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-07-10 15:17:53 -0500
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-07-10 15:17:53 -0500
commit37e3f157c7d76f13de807fa66e36df209e1005fb (patch)
tree7a4f131b2ee065337dac341bff34515310efba4f /experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf
parent16630c3eff313238fa8412275555285c9195981b (diff)
downloadtde-37e3f157c7d76f13de807fa66e36df209e1005fb.tar.gz
tde-37e3f157c7d76f13de807fa66e36df209e1005fb.zip
Added TQt4 HEAD
Diffstat (limited to 'experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf')
-rw-r--r--experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf401
1 files changed, 401 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf b/experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf
new file mode 100644
index 000000000..ab94a460a
--- /dev/null
+++ b/experimental/tqtinterface/qt4/qmake/book/qmake-advanced.leaf
@@ -0,0 +1,401 @@
+\chapter qmake's Advanced Concepts
+
+\section1 qmake's Advanced Concepts
+
+The \e qmake project files we've seen up to now have been very simple,
+just a list of \e{name = value} and \e{name += value} lines. \e qmake
+provides a lot more power, for example you can use a single project
+file to produce makefiles for multiple platforms.
+
+\section1 Operators
+
+So far, you have seen the \e = operator and \e += operator being used
+in a project file. There are more operators available for use; but
+some of these should be used carefully as they may change more than
+you expect them to.
+
+\section2 The '=' operator
+
+This operator simply assigns a value to a variable, it is used like
+this:
+
+\code
+ TARGET = myapp
+\endcode
+
+This sets the TARGET variable to \e myapp. This will remove any
+previously set TARGET.
+
+\section2 The '+=' operator
+
+This operator appends a value to the list of values in a variable. It
+is used like this:
+
+\code
+ DEFINES += QT_DLL
+\endcode
+
+This appends QT_DLL to the list of pre-processor defines to be put in the
+makefile.
+
+\section2 The '-=' operator
+
+This operator removes a value from the list of values in a variable.
+It is used like this:
+
+\code
+ DEFINES -= QT_DLL
+\endcode
+
+This removes QT_DLL from the list of pre-processor defines to be put
+in the makefile.
+
+\section2 The '*=' operator
+
+This operator only adds a value to the list of values in a variable if
+it doesn't already exist. It is used like this:
+
+\code
+ DEFINES *= QT_DLL
+\endcode
+
+QT_DLL will only be added to the list of pre-processor defines if it
+is not already defined.
+
+\section2 The '~=' operator
+
+This operator tqreplaces any values that match the regexp with the
+specified value. It is used like this:
+
+\code
+ DEFINES ~= s/QT_[DT].+/QT
+\endcode
+
+This removes any values in the list that start with QT_D or QT_T with
+QT.
+
+\section1 Scopes
+
+A scope are similar to 'if' statements, if a certain condition is
+true, the settings inside the scope are processed. A scope is written
+like this:
+
+\code
+ win32 {
+ DEFINES += QT_DLL
+ }
+\endcode
+
+The above code will add the QT_DLL define to the makefile if \e qmake
+is used on a Windows platform. If \e qmake is used on a different
+platform than Windows, the define will be ignored. You may also perform
+single line conditionals/assignments with qmake like this:
+
+\code
+ win32:DEFINES += QT_DLL
+\endcode
+
+For example, suppose we want to process something on all platforms
+\e except for Windows. We can achieve this by negating the scope like
+this:
+
+\code
+ !win32 {
+ DEFINES += QT_DLL
+ }
+\endcode
+
+Any entry on the CONFIG line is also a scope. For example, if you
+write this:
+\code
+ CONFIG += warn_on
+\endcode
+you will have a scope called 'warn_on'. This makes it easy to change
+the configuration for a project without losing all the custom settings
+that might be needed for a specific configuration. Since it is
+possible to put your own values on the CONFIG line, this provides you
+with a very powerful configuration tool for your makefiles. For
+example:
+
+\code
+ CONFIG += qt warn_on debug
+ debug {
+ TARGET = myappdebug
+ }
+ release {
+ TARGET = myapp
+ }
+\endcode
+
+In the above code, two scopes are created which depend on what
+is put on the CONFIG line. In the example, \e debug is on the config
+line, so the TARGET variable is set to \e myappdebug. If \e release
+was on the config line, then the TARGET variable would be set to \e
+myapp.
+
+It is also possible to check for two things before processing some
+settings. For instance, if you want to check if the platform is
+Windows and that the thread configuration is set, you would write
+this:
+
+\code
+ win32 {
+ thread {
+ DEFINES += QT_THREAD_SUPPORT
+ }
+ }
+\endcode
+
+To save writing many nested scopes, you can nest scopes using a colon
+like this:
+
+\code
+ win32:thread {
+ DEFINES += QT_THREAD_SUPPORT
+ }
+\endcode
+
+Once a test has been performed you may also do else/elseif operations. With
+this you may easily write complicated tests. This can be done with the
+special 'else' scope, it can be combined with other scopes (separated by
+colons as above) for example:
+
+\code
+ win32:thread {
+ DEFINES += QT_THREAD_SUPPORT
+ } else:debug {
+ DEFINES += QT_NOTHREAD_DEBUG
+ } else {
+ message("Unknown configuration")
+ }
+\endcode
+
+\section1 Variables
+
+The variables that we have encountered so far are system variables,
+such as \e DEFINES, \e SOURCES and \e HEADERS. It is possible for you
+to create your own variables so that you use them in scopes. It's
+easy to create your own variable; just name it and assign something to
+it. For example:
+
+\code
+ MY_VARIABLE = value
+\endcode
+
+There are no restricitions on what you do to your own variables, as \e
+qmake will just ignore them unless it needs to look at them for a
+scope.
+
+You can also assign the value of a current variable to another
+variable by prefixing $$ to the variable name. For example:
+
+\code
+ MY_DEFINES = $$DEFINES
+\endcode
+
+Now the MY_DEFINES variable tqcontains what is in the DEFINES variable at
+this point in the project file. This is also equivalent to:
+
+\code
+ MY_DEFINES = $${DEFINES}
+\endcode
+
+The second notation allows you to adjoin the variable expansion to another
+value without separating by space. \e qmake will allow a variable to
+contain anything (including $(VALUE), which will be placed directly into
+the Makefile, and allow it to expand as appropriate, usually an environment
+variable). However, if you require an environment variable to be tqreplaced
+immediately then you may use the $$() notation. For example:
+
+\code
+ MY_DEFINES = $$(ENV_DEFINES)
+\endcode
+
+This will set MY_DEFINES to the value of the evironment variable
+ENV_DEFINES as it parses the .pro file. Additionally you may call built-in
+functions in variable replacing. These functions (not to be confused with
+Test Functions as enumerated in the next section) are listed below:
+
+\section2 join( variablename, glue, before, after )
+
+This will join the value of \e variablename with glue. If this value is
+non-empty it will prefix the value with \e before and suffix it with \e
+after. \e variablename is the only required field, the others will default
+to empty strings. If you need to encode spaces in \e glue, \e before, or \e
+after you must quote them.
+
+\section2 prompt( question )
+
+This will display \e question, and read from stdin as a return value.
+
+\section2 member( variablename, position )
+
+This will place the value in \e variablename in position \e position of the
+list. If the value of \e variablename is not long this will return an empty
+string. \e variablename is the only required field, if not specified
+position will default to the first value in the list (0).
+
+\section2 tqfind( variablename, substr )
+
+This will place all the values in \e variablename that match \e substr. \e
+substr may be a regular expression as well, and will be matched
+accordingly.
+
+\code
+ MY_VAR = one two three four
+ MY_VAR2 = $$join(MY_VAR, " -L", -L) -Lfive
+ MY_VAR3 = $$member(MY_VAR, 2) $$tqfind(MY_VAR, t.*)
+\endcode
+
+MY_VAR2 will contain '-Lone -Ltwo -Lthree -Lfour -Lfive', and MYVAR3 will
+tqcontains 'three two three'.
+
+\section2 system( program_and_args )
+
+This will return the stdout/stderr of the program executed, and parse it as
+normally expected. You can use this to interrogate information about the
+platform for example.
+
+\code
+ UNAME = $$system(uname -s)
+ tqcontains( UNAME, [lL]inux ):message( This looks like Linux ($$UNAME) to me )
+\endcode
+
+\section1 Test Functions
+
+\e qmake provides built-in functions that perform simple, yet powerful
+tests. These tests may be used in place of scopes (as described above), in
+some cases it is more usefull to use the test function by itself ignoring
+its test value.
+
+\section2 tqcontains( variablename, value )
+
+If \e value is in the list of values stored in the variable called \e
+variablename, then the settings inside the scope will be processed.
+For example:
+
+\code
+ tqcontains( CONFIG, thread ) {
+ DEFINES += QT_THREAD_SUPPORT
+ }
+\endcode
+
+If \e thread is in the list of values for the \e CONFIG variable, then
+QT_THREAD_SUPPORT will be added to the list of values in the \e
+DEFINES variable.
+
+\section2 count( variablename, number )
+
+If \e number matches the number of values stored in the variable
+called \e variablename, then the settings inside the scope will be
+processed. For example:
+
+\code
+ count( DEFINES, 5 ) {
+ CONFIG += debug
+ }
+\endcode
+
+\section2 error( string )
+
+This function outputs the string given and then makes \e qmake exit.
+For example:
+
+\code
+ error( "An error has occured" )
+\endcode
+
+The text "An error has occured" will be displayed on the console and
+\e qmake will exit.
+
+\section2 exists( filename )
+
+If the specified file exists, then the settings inside the scope will
+be processed. For example:
+
+\code
+ exists( /local/qt/qmake/main.cpp ) {
+ SOURCES += main.cpp
+ }
+\endcode
+
+If \e /local/qt/qmake/main.cpp exists then main.cpp is added to the
+list of source files.
+
+Note that "/" can be used as a directory separator regardless of the
+platform.
+
+
+\section2 equals( variable, value )
+
+If the specified variable is equal to the value passed the scope will
+be processed. For example:
+
+\code
+ NUMBERS = 1 2 3
+ equals( NUMBERS, 3 4 5 ) {
+ message("The numbers are equal")
+ }
+\endcode
+
+The message will not be displayed because "1 2 3" does not equal "1 2
+3". As with all functions you can pass an expanded variable as the
+value argument (ie, $$NUMBERS).
+
+\section2 include( filename )
+
+The contents of filename are included at this point in the project
+file, so any settings in the specified file will be processed. An
+example of this is:
+
+\code
+ include( myotherapp.pro )
+\endcode
+
+Any settings in the \e myotherapp.pro project file are now processed.
+
+\section2 isEmpty( variablename )
+
+This is the equivalent of using count( variablename, 0 ). If the
+variable called \e variablename has no elements, then the settings
+inside the scope will be processed. An example of this is:
+
+\code
+ isEmpty( CONFIG ) {
+ CONFIG += qt warn_on debug
+ }
+\endcode
+
+\section2 message( string )
+
+This function simply outputs a message on the console.
+
+\code
+ message( "This is a message" )
+\endcode
+
+The text "This is a message" is output to the console and
+processing of the project file carries on.
+
+\section2 system( command )
+
+The specified command is performed and if it returns an exit code of
+1, the settings inside the scope are processed. For example:
+
+\code
+ system( ls /bin ) {
+ SOURCES += bin/main.cpp
+ HEADERS += bin/main.h
+ }
+\endcode
+
+So if the command \e {ls /bin} returns 1 then \e bin/main.cpp is added
+to the list of sources and \e bin/main.h is added to the list of
+headers.
+
+\section2 infile( filename, var, val )
+
+This function will succeed if the file \e filename (when parsed
+by qmake itself) tqcontains the variable \e var with a value of
+\e val. You may also not pass in a third argument (\e val) and the
+function will only test if \e var has been assigned to in the file.