reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-23 11:39:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
CMake/Modules/FindQt4.cmake

1339 lines
52 KiB
CMake
Raw Permalink Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 19:01:08 +00:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
#[=======================================================================[.rst:
FindQt4
-------
Finding and Using Qt4
^^^^^^^^^^^^^^^^^^^^^
This module can be used to find Qt4. The most important issue is that
the Qt4 qmake is available via the system path. This qmake is then
used to detect basically everything else. This module defines a
number of :prop_tgt:`IMPORTED` targets, macros and variables.
Typical usage could be something like:
.. code-block:: cmake
set(CMAKE_AUTOMOC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
find_package(Qt4 4.4.3 REQUIRED QtGui QtXml)
add_executable(myexe main.cpp)
target_link_libraries(myexe Qt4::QtGui Qt4::QtXml)
.. note::
When using :prop_tgt:`IMPORTED` targets, the qtmain.lib static library is
automatically linked on Windows for :prop_tgt:`WIN32 <WIN32_EXECUTABLE>`
executables. To disable that globally, set the
``QT4_NO_LINK_QTMAIN`` variable before finding Qt4. To disable that
for a particular executable, set the ``QT4_NO_LINK_QTMAIN`` target
property to ``TRUE`` on the executable.
Qt Build Tools
^^^^^^^^^^^^^^
Qt relies on some bundled tools for code generation, such as ``moc`` for
meta-object code generation,``uic`` for widget layout and population,
and ``rcc`` for virtual filesystem content generation. These tools may be
automatically invoked by :manual:`cmake(1)` if the appropriate conditions
are met. See :manual:`cmake-qt(7)` for more.
Qt Macros
^^^^^^^^^
In some cases it can be necessary or useful to invoke the Qt build tools in a
more-manual way. Several macros are available to add targets for such uses.
::
macro QT4_WRAP_CPP(outfiles inputfile ... [TARGET tgt] OPTIONS ...)
create moc code from a list of files containing Qt class with
the Q_OBJECT declaration. Per-directory preprocessor definitions
are also added. If the <tgt> is specified, the
INTERFACE_INCLUDE_DIRECTORIES and INTERFACE_COMPILE_DEFINITIONS from
the <tgt> are passed to moc. Options may be given to moc, such as
those found when executing "moc -help".
::
macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
create code from a list of Qt designer ui files.
Options may be given to uic, such as those found
when executing "uic -help"
::
macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
create code from a list of Qt resource files.
Options may be given to rcc, such as those found
when executing "rcc -help"
::
macro QT4_GENERATE_MOC(inputfile outputfile [TARGET tgt])
creates a rule to run moc on infile and create outfile.
Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
because you need a custom filename for the moc file or something
similar. If the <tgt> is specified, the
INTERFACE_INCLUDE_DIRECTORIES and INTERFACE_COMPILE_DEFINITIONS from
the <tgt> are passed to moc.
::
macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
Create the interface header and implementation files with the
given basename from the given interface xml file and add it to
the list of sources.
You can pass additional parameters to the qdbusxml2cpp call by setting
properties on the input file:
INCLUDE the given file will be included in the generate interface header
CLASSNAME the generated class is named accordingly
NO_NAMESPACE the generated class is not wrapped in a namespace
::
macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
Create the interface header and implementation files
for all listed interface xml files.
The basename will be automatically determined from the name
of the xml file.
The source file properties described for
QT4_ADD_DBUS_INTERFACE also apply here.
::
macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname
[basename] [classname])
create a dbus adaptor (header and implementation file) from the xml file
describing the interface, and add it to the list of sources. The adaptor
forwards the calls to a parent class, defined in parentheader and named
parentclassname. The name of the generated files will be
<basename>adaptor.{cpp,h} where basename defaults to the basename of the
xml file.
If <classname> is provided, then it will be used as the classname of the
adaptor itself.
::
macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
generate the xml interface file from the given header.
If the optional argument interfacename is omitted, the name of the
interface file is constructed from the basename of the header with
the suffix .xml appended.
Options may be given to qdbuscpp2xml, such as those found when
executing "qdbuscpp2xml --help"
::
macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
ts_files ... OPTIONS ...)
out: qm_files
in: directories sources ts_files
options: flags to pass to lupdate, such as -extensions to specify
extensions for a directory scan.
generates commands to create .ts (vie lupdate) and .qm
(via lrelease) - files from directories and/or sources. The ts files are
created and/or updated in the source tree (unless given with full paths).
The qm files are generated in the build tree.
Updating the translations can be done by adding the qm_files
to the source list of your library/executable, so they are
always updated, or by adding a custom target to control when
they get updated/generated.
::
macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
out: qm_files
in: ts_files
generates commands to create .qm from .ts - files. The generated
filenames can be found in qm_files. The ts_files
must exist and are not updated in any way.
::
macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... [TARGET tgt])
The qt4_automoc macro is obsolete. Use the CMAKE_AUTOMOC feature instead.
This macro is still experimental.
It can be used to have moc automatically handled.
So if you have the files foo.h and foo.cpp, and in foo.h a
a class uses the Q_OBJECT macro, moc has to run on it. If you don't
want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
#include "foo.moc"
in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will
scan all listed files at cmake-time for such included moc files and if it
finds them cause a rule to be generated to run moc at build time on the
accompanying header file foo.h.
If a source file has the SKIP_AUTOMOC property set it will be ignored by
this macro.
If the <tgt> is specified, the INTERFACE_INCLUDE_DIRECTORIES and
INTERFACE_COMPILE_DEFINITIONS from the <tgt> are passed to moc.
::
function QT4_USE_MODULES( target [link_type] modules...)
This function is obsolete. Use target_link_libraries with IMPORTED targets
instead.
Make <target> use the <modules> from Qt. Using a Qt module means
to link to the library, add the relevant include directories for the
module, and add the relevant compiler defines for using the module.
Modules are roughly equivalent to components of Qt4, so usage would be
something like:
qt4_use_modules(myexe Core Gui Declarative)
to use QtCore, QtGui and QtDeclarative. The optional <link_type> argument
can be specified as either LINK_PUBLIC or LINK_PRIVATE to specify the
same argument to the target_link_libraries call.
IMPORTED Targets
^^^^^^^^^^^^^^^^
A particular Qt library may be used by using the corresponding
:prop_tgt:`IMPORTED` target with the :command:`target_link_libraries`
command:
.. code-block:: cmake
target_link_libraries(myexe Qt4::QtGui Qt4::QtXml)
Using a target in this way causes :cmake(1)` to use the appropriate include
directories and compile definitions for the target when compiling ``myexe``.
Targets are aware of their dependencies, so for example it is not necessary
to list ``Qt4::QtCore`` if another Qt library is listed, and it is not
necessary to list ``Qt4::QtGui`` if ``Qt4::QtDeclarative`` is listed.
Targets may be tested for existence in the usual way with the
:command:`if(TARGET)` command.
The Qt toolkit may contain both debug and release libraries.
:manual:`cmake(1)` will choose the appropriate version based on the build
configuration.
``Qt4::QtCore``
The QtCore target
``Qt4::QtGui``
The QtGui target
``Qt4::Qt3Support``
The Qt3Support target
``Qt4::QtAssistant``
The QtAssistant target
``Qt4::QtAssistantClient``
The QtAssistantClient target
``Qt4::QAxContainer``
The QAxContainer target (Windows only)
``Qt4::QAxServer``
The QAxServer target (Windows only)
``Qt4::QtDBus``
The QtDBus target
``Qt4::QtDeclarative``
The QtDeclarative target
``Qt4::QtDesigner``
The QtDesigner target
``Qt4::QtDesignerComponents``
The QtDesignerComponents target
``Qt4::QtHelp``
The QtHelp target
``Qt4::QtMotif``
The QtMotif target
``Qt4::QtMultimedia``
The QtMultimedia target
``Qt4::QtNetwork``
The QtNetwork target
``Qt4::QtNsPLugin``
The QtNsPLugin target
``Qt4::QtOpenGL``
The QtOpenGL target
``Qt4::QtScript``
The QtScript target
``Qt4::QtScriptTools``
The QtScriptTools target
``Qt4::QtSql``
The QtSql target
``Qt4::QtSvg``
The QtSvg target
``Qt4::QtTest``
The QtTest target
``Qt4::QtUiTools``
The QtUiTools target
``Qt4::QtWebKit``
The QtWebKit target
``Qt4::QtXml``
The QtXml target
``Qt4::QtXmlPatterns``
The QtXmlPatterns target
``Qt4::phonon``
The phonon target
Result Variables
^^^^^^^^^^^^^^^^
Below is a detailed list of variables that FindQt4.cmake sets.
``Qt4_FOUND``
If false, don't try to use Qt 4.
``QT_FOUND``
If false, don't try to use Qt. This variable is for compatibility only.
``QT4_FOUND``
If false, don't try to use Qt 4. This variable is for compatibility only.
``QT_VERSION_MAJOR``
The major version of Qt found.
``QT_VERSION_MINOR``
The minor version of Qt found.
``QT_VERSION_PATCH``
The patch version of Qt found.
#]=======================================================================]
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
# Use find_package( Qt4 COMPONENTS ... ) to enable modules
if( Qt4_FIND_COMPONENTS )
foreach( component ${Qt4_FIND_COMPONENTS} )
string( TOUPPER ${component} _COMPONENT )
set( QT_USE_${_COMPONENT} 1 )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endforeach()
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
ENH: Support COMPONENTS argument to find_package(). See bug #8542.
2009-02-19 21:04:57 +00:00
# To make sure we don't use QtCore or QtGui when not in COMPONENTS
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT QT_USE_QTCORE)
set( QT_DONT_USE_QTCORE 1 )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT QT_USE_QTGUI)
set( QT_DONT_USE_QTGUI 1 )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
ENH: Support COMPONENTS argument to find_package(). See bug #8542.
2009-02-19 21:04:57 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
ENH: Support COMPONENTS argument to find_package(). See bug #8542.
2009-02-19 21:04:57 +00:00
BUG: fix #7447, FindModulesExecuteAll test fails if both Qt3 and KDE4 can be found in the system Qt3 and Qt4 cannot be used together in one project. Now Qt3/KDE3 and Qt4/KDE4 handle the case that this is done nevertheless properly, i.e. they fail with FATAL_ERROR if it was REQUIRED and they fail with just MESSAGE(STATUS ...) and RETURN() if it was not REQUIRED BUG: make FindQt4 error out with FATAL_ERROR also if it was searched QUIET Alex
2008-08-16 23:11:53 +00:00
# If Qt3 has already been found, fail.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_QT_LIBRARY)
if(Qt4_FIND_REQUIRED)
message( FATAL_ERROR "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT Qt4_FIND_QUIETLY)
message( STATUS "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
return()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif()
BUG: fix #7447, FindModulesExecuteAll test fails if both Qt3 and KDE4 can be found in the system Qt3 and Qt4 cannot be used together in one project. Now Qt3/KDE3 and Qt4/KDE4 handle the case that this is done nevertheless properly, i.e. they fail with FATAL_ERROR if it was REQUIRED and they fail with just MESSAGE(STATUS ...) and RETURN() if it was not REQUIRED BUG: make FindQt4 error out with FATAL_ERROR also if it was searched QUIET Alex
2008-08-16 23:11:53 +00:00
Find* (and some other): use ${CMAKE_CURRENT_LIST_DIR} in include() This solves a lots of warnings, e.g. in the FindModulesExecuteAll test. If the installed version on the system is rather old this may even lead to bugs, e.g. https://bugs.gentoo.org/show_bug.cgi?id=436540
2012-11-03 20:35:44 +00:00
include(${CMAKE_CURRENT_LIST_DIR}/CheckCXXSymbolExists.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/MacroAddFileDependencies.cmake)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
include(${CMAKE_CURRENT_LIST_DIR}/CMakePushCheckState.cmake)
ENH: add new qt stuff from warfield@bwh.harvard.edu, thanks
2005-07-15 16:14:47 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
ENH: add Ken Morelands fixes for FindQT
2005-09-08 13:58:41 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set( QT_DEFINITIONS "")
ENH: add Ken Morelands fixes for FindQT
2005-09-08 13:58:41 +00:00
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# convenience macro for dealing with debug/release library names
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
macro (_QT4_ADJUST_LIB_VARS _camelCaseBasename)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
string(TOUPPER "${_camelCaseBasename}" basename)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# The name of the imported targets, i.e. the prefix "Qt4::" must not change,
# since it is stored in EXPORT-files as name of a required library. If the name would change
# here, this would lead to the imported Qt4-library targets not being resolved by cmake anymore.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT TARGET Qt4::${_camelCaseBasename})
add_library(Qt4::${_camelCaseBasename} UNKNOWN IMPORTED )
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_LIBRARY_RELEASE)
set_property(TARGET Qt4::${_camelCaseBasename} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
FindQt4: Do not assume all libraries are frameworks Since on MacOSX not all modules are available as "framework" (e.g libQtUiTools.a), the assumption made in "FindQt4.cmake" is not always valid and systematically setting the imported libraries location to framework location is incorrect. This commit increases the robustness of the logic by first checking if the location exists. Fixes #17195
2017-08-21 20:18:49 +00:00
set(_location "${QT_${basename}_LIBRARY_RELEASE}")
if(QT_USE_FRAMEWORKS AND EXISTS ${_location}/${_camelCaseBasename})
set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_RELEASE "${_location}/${_camelCaseBasename}" )
Add imported targets support for frameworks on Mac.
2011-06-13 23:21:41 +00:00
else()
FindQt4: Do not assume all libraries are frameworks Since on MacOSX not all modules are available as "framework" (e.g libQtUiTools.a), the assumption made in "FindQt4.cmake" is not always valid and systematically setting the imported libraries location to framework location is incorrect. This commit increases the robustness of the logic by first checking if the location exists. Fixes #17195
2017-08-21 20:18:49 +00:00
set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_RELEASE "${_location}" )
Add imported targets support for frameworks on Mac.
2011-06-13 23:21:41 +00:00
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_LIBRARY_DEBUG)
set_property(TARGET Qt4::${_camelCaseBasename} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
FindQt4: Do not assume all libraries are frameworks Since on MacOSX not all modules are available as "framework" (e.g libQtUiTools.a), the assumption made in "FindQt4.cmake" is not always valid and systematically setting the imported libraries location to framework location is incorrect. This commit increases the robustness of the logic by first checking if the location exists. Fixes #17195
2017-08-21 20:18:49 +00:00
set(_location "${QT_${basename}_LIBRARY_DEBUG}")
if(QT_USE_FRAMEWORKS AND EXISTS ${_location}/${_camelCaseBasename})
set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_DEBUG "${_location}/${_camelCaseBasename}" )
Add imported targets support for frameworks on Mac.
2011-06-13 23:21:41 +00:00
else()
FindQt4: Do not assume all libraries are frameworks Since on MacOSX not all modules are available as "framework" (e.g libQtUiTools.a), the assumption made in "FindQt4.cmake" is not always valid and systematically setting the imported libraries location to framework location is incorrect. This commit increases the robustness of the logic by first checking if the location exists. Fixes #17195
2017-08-21 20:18:49 +00:00
set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_DEBUG "${_location}" )
Add imported targets support for frameworks on Mac.
2011-06-13 23:21:41 +00:00
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
FindQt4: Add INTERFACE includes and defines to Qt4 targets
2012-12-30 23:55:38 +00:00
set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY
INTERFACE_INCLUDE_DIRECTORIES
"${QT_${basename}_INCLUDE_DIR}"
)
string(REGEX REPLACE "^QT" "" _stemname ${basename})
set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY
INTERFACE_COMPILE_DEFINITIONS
"QT_${_stemname}_LIB"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# If QT_USE_IMPORTED_TARGETS is enabled, the QT_QTFOO_LIBRARY variables are set to point at these
# imported targets. This works better in general, and is also in almost all cases fully
# backward compatible. The only issue is when a project A which had this enabled then exports its
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
# libraries via export or export_library_dependencies(). In this case the libraries from project
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# A will depend on the imported Qt targets, and the names of these imported targets will be stored
# in the dependency files on disk. This means when a project B then uses project A, these imported
# targets must be created again, otherwise e.g. "Qt4__QtCore" will be interpreted as name of a
# library file on disk, and not as a target, and linking will fail:
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_USE_IMPORTED_TARGETS)
set(QT_${basename}_LIBRARY Qt4::${_camelCaseBasename} )
set(QT_${basename}_LIBRARIES Qt4::${_camelCaseBasename} )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# if the release- as well as the debug-version of the library have been found:
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_LIBRARY_DEBUG AND QT_${basename}_LIBRARY_RELEASE)
GENERATOR_IS_MULTI_CONFIG: Use for multi-config checks in Modules
2017-12-29 20:33:11 +00:00
# if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
# single-config generators, set optimized and debug libraries
get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(_isMultiConfig OR CMAKE_BUILD_TYPE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
GENERATOR_IS_MULTI_CONFIG: Use for multi-config checks in Modules
2017-12-29 20:33:11 +00:00
# For single-config generators where CMAKE_BUILD_TYPE has no value,
# just use the release libraries
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE} )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# if only the release version was found, set the debug variable also to the release version
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
set(QT_${basename}_LIBRARY_DEBUG ${QT_${basename}_LIBRARY_RELEASE})
set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE})
set(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_RELEASE})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# if only the debug version was found, set the release variable also to the debug version
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_LIBRARY_DEBUG AND NOT QT_${basename}_LIBRARY_RELEASE)
set(QT_${basename}_LIBRARY_RELEASE ${QT_${basename}_LIBRARY_DEBUG})
set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG})
set(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_DEBUG})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# put the value in the cache:
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE STRING "The Qt ${basename} library" FORCE)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_${basename}_FOUND 1)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else ()
Fix some issues with refinding when qmake executable is changed.
2010-07-06 19:24:53 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_${basename}_LIBRARY "" CACHE STRING "The Qt ${basename} library" FORCE)
Fix some issues with refinding when qmake executable is changed.
2010-07-06 19:24:53 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_${basename}_INCLUDE_DIR)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
#add the include directory to QT_INCLUDES
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_INCLUDES "${QT_${basename}_INCLUDE_DIR}" ${QT_INCLUDES})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Fix spelling and typos (non-binary)
2012-11-07 16:13:09 +00:00
# Make variables changeable to the advanced user
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
mark_as_advanced(QT_${basename}_LIBRARY QT_${basename}_LIBRARY_RELEASE QT_${basename}_LIBRARY_DEBUG QT_${basename}_INCLUDE_DIR)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endmacro ()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
function(_QT4_QUERY_QMAKE VAR RESULT)
Replace exec_program with execute_process for qmake queries.
2011-01-18 02:14:22 +00:00
execute_process(COMMAND "${QT_QMAKE_EXECUTABLE}" -query ${VAR}
RESULT_VARIABLE return_code
Fix errors detecting Qt4 on Windows 8. Thanks to Petr Baloun for the patch.
2012-08-24 15:54:31 +00:00
OUTPUT_VARIABLE output
Replace exec_program with execute_process for qmake queries.
2011-01-18 02:14:22 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
if(NOT return_code)
file(TO_CMAKE_PATH "${output}" output)
set(${RESULT} ${output} PARENT_SCOPE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endfunction()
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
function(_QT4_GET_VERSION_COMPONENTS VERSION RESULT_MAJOR RESULT_MINOR RESULT_PATCH)
string(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}")
string(REGEX REPLACE "^[0-9]+\\.([0-9]+)\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}")
string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}")
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
set(${RESULT_MAJOR} ${QT_VERSION_MAJOR} PARENT_SCOPE)
set(${RESULT_MINOR} ${QT_VERSION_MINOR} PARENT_SCOPE)
set(${RESULT_PATCH} ${QT_VERSION_PATCH} PARENT_SCOPE)
endfunction()
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
function(_QT4_FIND_QMAKE QMAKE_NAMES QMAKE_RESULT VERSION_RESULT)
list(LENGTH QMAKE_NAMES QMAKE_NAMES_LEN)
if(${QMAKE_NAMES_LEN} EQUAL 0)
return()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
list(GET QMAKE_NAMES 0 QMAKE_NAME)
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
get_filename_component(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
find_program(QT_QMAKE_EXECUTABLE NAMES ${QMAKE_NAME}
PATHS
ENV QTDIR
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]"
PATH_SUFFIXES bin
DOC "The qmake executable for the Qt installation to use"
)
set(major 0)
if (QT_QMAKE_EXECUTABLE)
_qt4_query_qmake(QT_VERSION QTVERSION)
_qt4_get_version_components("${QTVERSION}" major minor patch)
endif()
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
if (NOT QT_QMAKE_EXECUTABLE OR NOT "${major}" EQUAL 4)
set(curr_qmake "${QT_QMAKE_EXECUTABLE}")
set(curr_qt_version "${QTVERSION}")
STYLE: some whitespace syncing with FindQt4.cmake in KDE svn Alex
2007-12-16 10:49:23 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
list(REMOVE_AT QMAKE_NAMES 0)
_qt4_find_qmake("${QMAKE_NAMES}" QMAKE QTVERSION)
_qt4_get_version_components("${QTVERSION}" major minor patch)
if (NOT ${major} EQUAL 4)
# Restore possibly found qmake and it's version; these are used later
# in error message if incorrect version is found
set(QT_QMAKE_EXECUTABLE "${curr_qmake}" CACHE FILEPATH "" FORCE)
set(QTVERSION "${curr_qt_version}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
BUG: also look for qmake4, as it is named on OpenBSD Alex
2007-01-04 21:35:47 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
FindQt4: Fix QT_QMAKE{_QMAKE => }_EXECUTABLE typo The parent commit accidentally referenced QT_QMAKE_QMAKE_EXECUTABLE which does not exist. Use QT_QMAKE_EXECUTABLE instead. Reported-by: m.hergarden@euphoria-it.nl
2013-03-13 11:54:36 +00:00
set(${QMAKE_RESULT} "${QT_QMAKE_EXECUTABLE}" PARENT_SCOPE)
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
set(${VERSION_RESULT} "${QTVERSION}" PARENT_SCOPE)
endfunction()
set(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
set(_QT4_QMAKE_NAMES qmake qmake4 qmake-qt4 qmake-mac)
_qt4_find_qmake("${_QT4_QMAKE_NAMES}" QT_QMAKE_EXECUTABLE QTVERSION)
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
FindQt4: Don't further process qmake if it does not belong to Qt4 If the only qmake that can be found belongs to Qt5 the find module would otherwise still further interrogate it and issue diagnostics which are specific to Qt4.
2014-06-25 13:57:27 +00:00
if (QT_QMAKE_EXECUTABLE AND
QTVERSION VERSION_GREATER 3 AND QTVERSION VERSION_LESS 5)
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
FindQt4: Make AUTOMOC work regardless which order Qt 4/5 is found. Commit 321e348e (QtAutogen: Use Qt 4 IMPORTED targets to find executable locations., 2014-01-24) attempted to fix this problem, but only solved it for a particular ordering of find_package for Qt 4 and Qt 5. Add a test to ensure that it works with both orderings.
2014-01-29 15:57:09 +00:00
if (Qt5Core_FOUND)
# Qt5CoreConfig sets QT_MOC_EXECUTABLE as a non-cache variable to the Qt 5
# path to moc. Unset that variable when Qt 4 and 5 are used together, so
# that when find_program looks for moc, it is not set to the Qt 5 version.
# If FindQt4 has already put the Qt 4 path in the cache, the unset()
# command 'unhides' the (correct) cache variable.
unset(QT_MOC_EXECUTABLE)
endif()
FindQt4: Restore ability to handle a changed QT_QMAKE_EXECUTABLE properly. This fixes a regression in commit 21123416 where it was trying to better handle a qmake from Qt5.
2013-12-05 22:21:03 +00:00
if (QT_QMAKE_EXECUTABLE_LAST)
string(COMPARE NOTEQUAL "${QT_QMAKE_EXECUTABLE_LAST}" "${QT_QMAKE_EXECUTABLE}" QT_QMAKE_CHANGED)
endif()
set(QT_QMAKE_EXECUTABLE_LAST "${QT_QMAKE_EXECUTABLE}" CACHE INTERNAL "" FORCE)
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
_qt4_get_version_components("${QTVERSION}" QT_VERSION_MAJOR QT_VERSION_MINOR QT_VERSION_PATCH)
FindQt4: set QT_VERSION_* variables sooner. Set QT_VERSION_* variables sooner so they can be set before Qt4ConfigDependentSettings.cmake uses them.
2013-01-07 18:06:35 +00:00
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# ask qmake for the mkspecs directory
# we do this first because QT_LIBINFIX might be set
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (NOT QT_MKSPECS_DIR OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QMAKE_MKSPECS qt_mkspecs_dirs)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# do not replace : on windows as it might be a drive letter
# and windows should already use ; as a separator
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT WIN32)
string(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
FindQt4: New IMPORTS, PLUGINS and MKSPECS handling Fixes: #14155
2018-05-10 17:40:51 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(QT_MKSPECS_DIR NAMES qconfig.pri
FindQt4: New IMPORTS, PLUGINS and MKSPECS handling Fixes: #14155
2018-05-10 17:40:51 +00:00
HINTS ${qt_mkspecs_dirs}
PATH_SUFFIXES mkspecs share/qt4/mkspecs
DOC "The location of the Qt mkspecs containing qconfig.pri")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
endif()
if(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
file(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents)
string(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG "${_qconfig_FILE_contents}")
string(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG "${_qconfig_FILE_contents}")
string(REGEX MATCH "EDITION[^\n]+" QT_EDITION "${_qconfig_FILE_contents}")
string(REGEX MATCH "QT_LIBINFIX[^\n]+" _qconfig_qt_libinfix "${_qconfig_FILE_contents}")
string(REGEX REPLACE "QT_LIBINFIX *= *([^\n]*)" "\\1" QT_LIBINFIX "${_qconfig_qt_libinfix}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if("${QT_EDITION}" MATCHES "DesktopLight")
set(QT_EDITION_DESKTOPLIGHT 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# ask qmake for the library dir as a hint, then search for QtCore library and use that as a reference for finding the
# others and for setting QT_LIBRARY_DIR
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (NOT (QT_QTCORE_LIBRARY_RELEASE OR QT_QTCORE_LIBRARY_DEBUG) OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_LIBS QT_LIBRARY_DIR_TMP)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_QTCORE_LIBRARY_RELEASE NOTFOUND)
set(QT_QTCORE_LIBRARY_DEBUG NOTFOUND)
find_library(QT_QTCORE_LIBRARY_RELEASE
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
NAMES QtCore${QT_LIBINFIX} QtCore${QT_LIBINFIX}4
HINTS ${QT_LIBRARY_DIR_TMP}
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
NO_DEFAULT_PATH
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_QTCORE_LIBRARY_DEBUG
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
NAMES QtCore${QT_LIBINFIX}_debug QtCore${QT_LIBINFIX}d QtCore${QT_LIBINFIX}d4
HINTS ${QT_LIBRARY_DIR_TMP}
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
NO_DEFAULT_PATH
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
)
Fix mingw/VS warning message with cross compile re-org.
2010-07-15 16:23:32 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCORE_LIBRARY_DEBUG)
find_library(QT_QTCORE_LIBRARY_RELEASE
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
NAMES QtCore${QT_LIBINFIX} QtCore${QT_LIBINFIX}4
HINTS ${QT_LIBRARY_DIR_TMP}
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_QTCORE_LIBRARY_DEBUG
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
NAMES QtCore${QT_LIBINFIX}_debug QtCore${QT_LIBINFIX}d QtCore${QT_LIBINFIX}d4
HINTS ${QT_LIBRARY_DIR_TMP}
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
Fix spelling and typos (product names) API, Borland, MinGW, UNIX, Mac OS X.
2013-05-04 12:53:26 +00:00
# try dropping a hint if trying to use Visual Studio with Qt built by MinGW
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT QT_QTCORE_LIBRARY_RELEASE AND MSVC)
if(EXISTS ${QT_LIBRARY_DIR_TMP}/libqtmain.a)
Fix spelling and typos (product names) API, Borland, MinGW, UNIX, Mac OS X.
2013-05-04 12:53:26 +00:00
message( FATAL_ERROR "It appears you're trying to use Visual Studio with Qt built by MinGW. Those compilers do not produce code compatible with each other.")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif()
Fix mingw/VS warning message with cross compile re-org.
2010-07-15 16:23:32 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
endif ()
Add imported targets support for frameworks on Mac.
2011-06-13 23:21:41 +00:00
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# set QT_LIBRARY_DIR based on location of QtCore found.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_QTCORE_LIBRARY_RELEASE)
get_filename_component(QT_LIBRARY_DIR_TMP "${QT_QTCORE_LIBRARY_RELEASE}" PATH)
set(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE INTERNAL "Qt library dir" FORCE)
set(QT_QTCORE_FOUND 1)
elseif(QT_QTCORE_LIBRARY_DEBUG)
get_filename_component(QT_LIBRARY_DIR_TMP "${QT_QTCORE_LIBRARY_DEBUG}" PATH)
set(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE INTERNAL "Qt library dir" FORCE)
set(QT_QTCORE_FOUND 1)
else()
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
if(NOT Qt4_FIND_QUIETLY)
message(WARNING
"${QT_QMAKE_EXECUTABLE} reported QT_INSTALL_LIBS as "
"\"${QT_LIBRARY_DIR_TMP}\" "
"but QtCore could not be found there. "
"Qt is NOT installed correctly for the target build environment.")
endif()
FindQt4: Fix QUIET failure with Qt 5 but not Qt 4 The call find_package(Qt4 QUIET) should be non-FATAL in that case. This fixes #14142.
2013-05-15 14:17:41 +00:00
set(Qt4_FOUND FALSE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Qt4_FIND_REQUIRED)
message( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
FindQt4: Fix QUIET failure with Qt 5 but not Qt 4 The call find_package(Qt4 QUIET) should be non-FATAL in that case. This fixes #14142.
2013-05-15 14:17:41 +00:00
else()
return()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
endif()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
# ask qmake for the binary dir
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (NOT QT_BINARY_DIR OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_BINS qt_bins)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "" FORCE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (APPLE)
set(CMAKE_FIND_FRAMEWORK_OLD ${CMAKE_FIND_FRAMEWORK})
if (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
set(QT_USE_FRAMEWORKS ON CACHE INTERNAL "" FORCE)
set(CMAKE_FIND_FRAMEWORK FIRST)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_USE_FRAMEWORKS OFF CACHE INTERNAL "" FORCE)
set(CMAKE_FIND_FRAMEWORK LAST)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif ()
Qt4: Fix reference of undefined variable when detecting frameworks on Mac OS X
2011-07-25 18:30:30 +00:00
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
# ask qmake for the include dir
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_LIBRARY_DIR AND (NOT QT_QTCORE_INCLUDE_DIR OR NOT QT_HEADERS_DIR OR QT_QMAKE_CHANGED))
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_HEADERS qt_headers)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_QTCORE_INCLUDE_DIR NOTFOUND)
find_path(QT_QTCORE_INCLUDE_DIR QtCore
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
HINTS ${qt_headers} ${QT_LIBRARY_DIR}
Add qt4/QtCore to help find Qt headers when cross-compiling.
2011-07-22 19:38:36 +00:00
PATH_SUFFIXES QtCore qt4/QtCore
FindQt4: If Qt5 is in CMAKE_PREFIX_PATH, be sure to find Qt4 includes.
2013-03-15 14:32:43 +00:00
NO_DEFAULT_PATH
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
)
FindQt4: If Qt5 is in CMAKE_PREFIX_PATH, be sure to find Qt4 includes.
2013-03-15 14:32:43 +00:00
if(NOT QT_QTCORE_INCLUDE_DIR)
find_path(QT_QTCORE_INCLUDE_DIR QtCore
HINTS ${qt_headers} ${QT_LIBRARY_DIR}
PATH_SUFFIXES QtCore qt4/QtCore
)
endif()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# Set QT_HEADERS_DIR based on finding QtCore header
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_QTCORE_INCLUDE_DIR)
if(QT_USE_FRAMEWORKS)
set(QT_HEADERS_DIR "${qt_headers}" CACHE INTERNAL "" FORCE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
get_filename_component(qt_headers "${QT_QTCORE_INCLUDE_DIR}/../" ABSOLUTE)
set(QT_HEADERS_DIR "${qt_headers}" CACHE INTERNAL "" FORCE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Fix elseif() in place of else()
2019-07-03 08:57:08 +00:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
message("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_HEADERS as ${qt_headers}")
message("Warning: But QtCore couldn't be found. Qt must NOT be installed correctly.")
endif()
endif()
if(APPLE)
set(CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_OLD})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Fix issues with find_path() for QtCore include dir on Mac. Fixes 11868.
2011-02-19 22:30:02 +00:00
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# Set QT_INCLUDE_DIR based on QT_HEADERS_DIR
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_HEADERS_DIR)
if(QT_USE_FRAMEWORKS)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# Qt/Mac frameworks has two include dirs.
# One is the framework include for which CMake will add a -F flag
# and the other is an include dir for non-framework Qt modules
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_INCLUDE_DIR ${QT_HEADERS_DIR} ${QT_QTCORE_LIBRARY_RELEASE} )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_INCLUDE_DIR ${QT_HEADERS_DIR})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
# Set QT_INCLUDES
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set( QT_INCLUDES ${QT_MKSPECS_DIR}/default ${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR})
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
# ask qmake for the documentation directory
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_LIBRARY_DIR AND NOT QT_DOC_DIR OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_DOCS qt_doc_dir)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs" FORCE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
BUG: fix for bug#3898 find qt plugin dir
2006-10-13 15:23:44 +00:00
# ask qmake for the plugins directory
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_PLUGINS qt_plugins_dir)
FindQt4: New IMPORTS, PLUGINS and MKSPECS handling Fixes: #14155
2018-05-10 17:40:51 +00:00
if(CMAKE_CROSSCOMPILING OR NOT qt_plugins_dir)
find_path(QT_PLUGINS_DIR
NAMES accessible bearer codecs designer graphicssystems iconengines imageformats inputmethods qmltooling script sqldrivers
HINTS ${qt_plugins_dir}
PATH_SUFFIXES plugins lib/qt4/plugins
DOC "The location of the Qt plugins")
else()
set(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins")
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
BUG: Fix for #8247. Add QT_TRANSLATIONS_DIR pointing to the Qt translation files, and docs for it. Also add docs for QT_BINARY_DIR.
2008-12-15 23:48:48 +00:00
# ask qmake for the translations directory
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_TRANSLATIONS qt_translations_dir)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_TRANSLATIONS_DIR ${qt_translations_dir} CACHE PATH "The location of the Qt translations" FORCE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
BUG: Fix for #8247. Add QT_TRANSLATIONS_DIR pointing to the Qt translation files, and docs for it. Also add docs for QT_BINARY_DIR.
2008-12-15 23:48:48 +00:00
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
# ask qmake for the imports directory
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_LIBRARY_DIR AND NOT QT_IMPORTS_DIR OR QT_QMAKE_CHANGED)
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
_qt4_query_qmake(QT_INSTALL_IMPORTS qt_imports_dir)
FindQt4: New IMPORTS, PLUGINS and MKSPECS handling Fixes: #14155
2018-05-10 17:40:51 +00:00
if(CMAKE_CROSSCOMPILING OR NOT qt_imports_dir)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(QT_IMPORTS_DIR NAMES Qt
FindQt4: New IMPORTS, PLUGINS and MKSPECS handling Fixes: #14155
2018-05-10 17:40:51 +00:00
HINTS ${qt_imports_dir}
PATH_SUFFIXES imports lib/qt4/imports
DOC "The location of the Qt imports")
else()
set(QT_IMPORTS_DIR ${qt_imports_dir} CACHE PATH "The location of the Qt imports")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif ()
Find imports dir in Qt 4.7
2010-10-09 02:55:55 +00:00
Fix spelling and typos (non-binary)
2012-11-07 16:13:09 +00:00
# Make variables changeable to the advanced user
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
mark_as_advanced( QT_LIBRARY_DIR QT_DOC_DIR QT_MKSPECS_DIR
some syncing with FindQt4.cmake from KDE, no functional changes -the mark_as_advanced() calls for the variables coming from qmake are now in the corresponding section, and not in the section where the include dirs are foudn Alex
2009-11-08 18:01:46 +00:00
QT_PLUGINS_DIR QT_TRANSLATIONS_DIR)
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
Don't search for QtMotif on all platforms - only on X11.
2009-11-17 19:44:33 +00:00
#############################################
#
# Find out what window system we're using
#
#############################################
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
cmake_push_check_state()
Don't search for QtMotif on all platforms - only on X11.
2009-11-17 19:44:33 +00:00
# Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
prefer list(APPEND) over string(APPEND) where appropriate
2016-08-08 19:25:41 +00:00
list(APPEND CMAKE_REQUIRED_INCLUDES "${QT_INCLUDE_DIR}")
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
set(CMAKE_REQUIRED_QUIET ${Qt4_FIND_QUIETLY})
Don't search for QtMotif on all platforms - only on X11.
2009-11-17 19:44:33 +00:00
# Check for Window system symbols (note: only one should end up being set)
Remove C compiler requirement from FindQt4.cmake Use the new check_cxx_symbol_exists instead of check_symbol_exists. Also remove a debug message from CheckSymbolExists.cmake.
2011-07-28 18:15:46 +00:00
CHECK_CXX_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
CHECK_CXX_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
CHECK_CXX_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
CHECK_CXX_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Q_WS_MAC)
if(QT_QMAKE_CHANGED)
unset(QT_MAC_USE_COCOA CACHE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Remove C compiler requirement from FindQt4.cmake Use the new check_cxx_symbol_exists instead of check_symbol_exists. Also remove a debug message from CheckSymbolExists.cmake.
2011-07-28 18:15:46 +00:00
CHECK_CXX_SYMBOL_EXISTS(QT_MAC_USE_COCOA "QtCore/qconfig.h" QT_MAC_USE_COCOA)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Don't search for QtMotif on all platforms - only on X11.
2009-11-17 19:44:33 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_QTCOPY_REQUIRED)
Remove C compiler requirement from FindQt4.cmake Use the new check_cxx_symbol_exists instead of check_symbol_exists. Also remove a debug message from CheckSymbolExists.cmake.
2011-07-28 18:15:46 +00:00
CHECK_CXX_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (NOT QT_IS_QTCOPY)
message(FATAL_ERROR "qt-copy is required, but hasn't been found")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif ()
Don't search for QtMotif on all platforms - only on X11.
2009-11-17 19:44:33 +00:00
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
cmake_pop_check_state()
Don't search for QtMotif on all platforms - only on X11.
2009-11-17 19:44:33 +00:00
#
#############################################
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
########################################
#
# Setting the INCLUDE-Variables
#
########################################
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_MODULES QtGui Qt3Support QtSvg QtScript QtTest QtUiTools
-add support for QtMultimedia and some sync with KDE -the QtMultimedia module is new since Qt 4.6.0 -sort the doc entries alphabetically Alex
2009-12-20 14:06:42 +00:00
QtHelp QtWebKit QtXmlPatterns phonon QtNetwork QtMultimedia
Add support for QtDeclartive module.
2010-02-18 00:12:18 +00:00
QtNsPlugin QtOpenGL QtSql QtXml QtDesigner QtDBus QtScriptTools
QtDeclarative)
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Q_WS_X11)
set(QT_MODULES ${QT_MODULES} QtMotif)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_QMAKE_CHANGED)
foreach(QT_MODULE ${QT_MODULES})
string(TOUPPER ${QT_MODULE} _upper_qt_module)
set(QT_${_upper_qt_module}_INCLUDE_DIR NOTFOUND)
set(QT_${_upper_qt_module}_LIBRARY_RELEASE NOTFOUND)
set(QT_${_upper_qt_module}_LIBRARY_DEBUG NOTFOUND)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endforeach()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR NOTFOUND)
set(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NOTFOUND)
set(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NOTFOUND)
set(QT_QTASSISTANTCLIENT_INCLUDE_DIR NOTFOUND)
set(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NOTFOUND)
set(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NOTFOUND)
set(QT_QTASSISTANT_INCLUDE_DIR NOTFOUND)
set(QT_QTASSISTANT_LIBRARY_RELEASE NOTFOUND)
set(QT_QTASSISTANT_LIBRARY_DEBUG NOTFOUND)
set(QT_QTCLUCENE_LIBRARY_RELEASE NOTFOUND)
set(QT_QTCLUCENE_LIBRARY_DEBUG NOTFOUND)
set(QT_QAXCONTAINER_INCLUDE_DIR NOTFOUND)
set(QT_QAXCONTAINER_LIBRARY_RELEASE NOTFOUND)
set(QT_QAXCONTAINER_LIBRARY_DEBUG NOTFOUND)
set(QT_QAXSERVER_INCLUDE_DIR NOTFOUND)
set(QT_QAXSERVER_LIBRARY_RELEASE NOTFOUND)
set(QT_QAXSERVER_LIBRARY_DEBUG NOTFOUND)
if(Q_WS_WIN)
set(QT_QTMAIN_LIBRARY_DEBUG NOTFOUND)
set(QT_QTMAIN_LIBRARY_RELEASE NOTFOUND)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
foreach(QT_MODULE ${QT_MODULES})
string(TOUPPER ${QT_MODULE} _upper_qt_module)
find_path(QT_${_upper_qt_module}_INCLUDE_DIR ${QT_MODULE}
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
PATHS
${QT_HEADERS_DIR}/${QT_MODULE}
${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
)
Fix bug #10114. Find phonon on some installations.
2010-01-13 22:34:31 +00:00
# phonon doesn't seem consistent, let's try phonondefs.h for some
# installations
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(${QT_MODULE} STREQUAL "phonon")
find_path(QT_${_upper_qt_module}_INCLUDE_DIR phonondefs.h
Fix bug #10114. Find phonon on some installations.
2010-01-13 22:34:31 +00:00
PATHS
${QT_HEADERS_DIR}/${QT_MODULE}
${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
Fix bug #10114. Find phonon on some installations.
2010-01-13 22:34:31 +00:00
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endforeach()
some syncing with FindQt4.cmake from KDE, no functional changes -the mark_as_advanced() calls for the variables coming from qmake are now in the corresponding section, and not in the section where the include dirs are foudn Alex
2009-11-08 18:01:46 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Q_WS_WIN)
FindQt4: Re-add QAxServer to the QT_MODULES. This was removed instead of moved in commit b8af46cb (FindQt4: Don't fail if certain Qt modules are unavailable.).
2013-07-24 15:59:13 +00:00
set(QT_MODULES ${QT_MODULES} QAxContainer QAxServer)
FindQt4: Don't use Qt component _FOUND vars before they're defined (#14286) This fixes a regression introduced by commit b8af46cb (FindQt4: Don't fail if certain Qt modules are unavailable., 2013-05-23) The _FOUND variable is set by the _QT4_ADJUST_LIB_VARS macro, so invoke that unconditionally, and guard only the set_property calls, as described in the original bug report (#14165).
2013-07-22 12:27:22 +00:00
# Set QT_AXCONTAINER_INCLUDE_DIR and QT_AXSERVER_INCLUDE_DIR
find_path(QT_QAXCONTAINER_INCLUDE_DIR ActiveQt
PATHS ${QT_HEADERS_DIR}/ActiveQt
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
)
find_path(QT_QAXSERVER_INCLUDE_DIR ActiveQt
PATHS ${QT_HEADERS_DIR}/ActiveQt
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
some syncing with FindQt4.cmake from KDE, no functional changes -the mark_as_advanced() calls for the variables coming from qmake are now in the corresponding section, and not in the section where the include dirs are foudn Alex
2009-11-08 18:01:46 +00:00
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
# Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
ENH: use PATHS keyword
2008-05-23 19:25:26 +00:00
PATHS
BUG: Fixed recent regression when finding some includes.
2009-01-26 15:12:37 +00:00
${QT_HEADERS_DIR}/QtDesigner
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
${QT_LIBRARY_DIR}/QtDesigner.framework/Headers
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
ENH: make qmake-qt4 really work if qmake is qt3 also fix indent in file, for diff use cvs diff -w
2006-10-04 14:33:10 +00:00
)
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
BUG: Fix regression in finding QtAssistant
2008-10-20 17:31:50 +00:00
# Set QT_QTASSISTANT_INCLUDE_DIR
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(QT_QTASSISTANT_INCLUDE_DIR QtAssistant
BUG: Fix regression in finding QtAssistant
2008-10-20 17:31:50 +00:00
PATHS
BUG: Fixed recent regression when finding some includes.
2009-01-26 15:12:37 +00:00
${QT_HEADERS_DIR}/QtAssistant
BUG: Fix regression in finding QtAssistant
2008-10-20 17:31:50 +00:00
${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
BUG: Fix regression in finding QtAssistant
2008-10-20 17:31:50 +00:00
)
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
# Set QT_QTASSISTANTCLIENT_INCLUDE_DIR
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(QT_QTASSISTANTCLIENT_INCLUDE_DIR QAssistantClient
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
PATHS
BUG: Fixed recent regression when finding some includes.
2009-01-26 15:12:37 +00:00
${QT_HEADERS_DIR}/QtAssistant
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
)
some syncing with FindQt4.cmake from KDE, no functional changes -the mark_as_advanced() calls for the variables coming from qmake are now in the corresponding section, and not in the section where the include dirs are foudn Alex
2009-11-08 18:01:46 +00:00
########################################
#
# Setting the LIBRARY-Variables
#
########################################
document how the minimum version can be specified Alex
2009-10-01 20:48:19 +00:00
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
# find the libraries
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
foreach(QT_MODULE ${QT_MODULES})
string(TOUPPER ${QT_MODULE} _upper_qt_module)
find_library(QT_${_upper_qt_module}_LIBRARY_RELEASE
Add support for Qt configured with custom qtlibinfix (see issue 9571). Also fix CMP 15 warnings.
2009-09-22 20:28:13 +00:00
NAMES ${QT_MODULE}${QT_LIBINFIX} ${QT_MODULE}${QT_LIBINFIX}4
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_${_upper_qt_module}_LIBRARY_DEBUG
Add support for Qt configured with custom qtlibinfix (see issue 9571). Also fix CMP 15 warnings.
2009-09-22 20:28:13 +00:00
NAMES ${QT_MODULE}${QT_LIBINFIX}_debug ${QT_MODULE}${QT_LIBINFIX}d ${QT_MODULE}${QT_LIBINFIX}d4
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
ENH: When changing the qmake pointed to, re-find all of Qt's includes, libraries, etc... This makes it much easier to switch between Qt versions.
2008-10-14 02:12:54 +00:00
)
FindQt4: Avoid "finding" non-existent library in a .framework ...if the library file does not exist inside the .framework then do not allow a library variable to be set to the path to the framework. Force set it to NOTFOUND instead.
2012-09-06 19:11:54 +00:00
if(QT_${_upper_qt_module}_LIBRARY_RELEASE MATCHES "/${QT_MODULE}\\.framework$")
if(NOT EXISTS "${QT_${_upper_qt_module}_LIBRARY_RELEASE}/${QT_MODULE}")
# Release framework library file does not exist... Force to NOTFOUND:
set(QT_${_upper_qt_module}_LIBRARY_RELEASE "QT_${_upper_qt_module}_LIBRARY_RELEASE-NOTFOUND" CACHE FILEPATH "Path to a library." FORCE)
endif()
endif()
if(QT_${_upper_qt_module}_LIBRARY_DEBUG MATCHES "/${QT_MODULE}\\.framework$")
if(NOT EXISTS "${QT_${_upper_qt_module}_LIBRARY_DEBUG}/${QT_MODULE}")
# Debug framework library file does not exist... Force to NOTFOUND:
set(QT_${_upper_qt_module}_LIBRARY_DEBUG "QT_${_upper_qt_module}_LIBRARY_DEBUG-NOTFOUND" CACHE FILEPATH "Path to a library." FORCE)
endif()
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endforeach()
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
qt4: also find QtUiTools when cross compiling with mingw.
2011-08-29 14:23:44 +00:00
# QtUiTools is sometimes not in the same directory as the other found libraries
# e.g. on Mac, its never a framework like the others are
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
find_library(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
ENH: partly sync with KDE svn: also find the QtDBus and the QtDesignerComponents libraries Alex
2007-01-03 21:38:26 +00:00
# Set QT_QTDESIGNERCOMPONENTS_LIBRARY
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents${QT_LIBINFIX} QtDesignerComponents${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
find_library(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NAMES QtDesignerComponents${QT_LIBINFIX}_debug QtDesignerComponents${QT_LIBINFIX}d QtDesignerComponents${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
ENH: partly sync with KDE svn: also find the QtDBus and the QtDesignerComponents libraries Alex
2007-01-03 21:38:26 +00:00
ENH: put back find qtmain
2006-08-01 13:12:18 +00:00
# Set QT_QTMAIN_LIBRARY
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Q_WS_WIN)
find_library(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
find_library(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmain${QT_LIBINFIX}d PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
ENH: Add support for new modules in Qt 4.4. Fixes #6316. Simplify and clarify some documentation. BUG: Fix order of include paths (from KDE's FindQt4) Fix find of Designer components debug library on Windows.
2008-03-13 19:29:28 +00:00
# Set QT_QTASSISTANTCLIENT_LIBRARY
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
find_library(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NAMES QtAssistantClient${QT_LIBINFIX}_debug QtAssistantClient${QT_LIBINFIX}d QtAssistantClient${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
BUG: Fix regression in finding QtAssistant
2008-10-20 17:31:50 +00:00
# Set QT_QTASSISTANT_LIBRARY
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 QtAssistant${QT_LIBINFIX} QtAssistant${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
find_library(QT_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClient${QT_LIBINFIX}_debug QtAssistantClient${QT_LIBINFIX}d QtAssistantClient${QT_LIBINFIX}d4 QtAssistant${QT_LIBINFIX}_debug QtAssistant${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
ENH: Add support for new modules in Qt 4.4. Fixes #6316. Simplify and clarify some documentation. BUG: Fix order of include paths (from KDE's FindQt4) Fix find of Designer components debug library on Windows.
2008-03-13 19:29:28 +00:00
# Set QT_QTHELP_LIBRARY
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} QtCLucene${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
find_library(QT_QTCLUCENE_LIBRARY_DEBUG NAMES QtCLucene${QT_LIBINFIX}_debug QtCLucene${QT_LIBINFIX}d QtCLucene${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
if(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
find_library(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
ENH: Add support for new modules in Qt 4.4. Fixes #6316. Simplify and clarify some documentation. BUG: Fix order of include paths (from KDE's FindQt4) Fix find of Designer components debug library on Windows.
2008-03-13 19:29:28 +00:00
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
############################################
#
# Check the existence of the libraries.
#
############################################
-make the imported targets feature of FindQt4.cmake fully backwards compatible After discussing with Brad and Clinton: -the namespace for the imported targets is now "Qt4::", tested with Makefiles, Visual Studio and XCode projects -the imported targets are always created -if QT_USE_IMPORTED_TARGETS is set to TRUE (it defaults to FALSE), the QT_QTFOO_LIBRARY variables are set to point to these imported targets, otherwise the old behaviour is used. -on OSX if Qt has been found as framework, disable QT_USE_IMPORTED_TARGETS, since cmake doesn't handle the framework directory as location of the library correctly Alex
2010-01-18 21:23:21 +00:00
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
macro(_qt4_add_target_depends_internal _QT_MODULE _PROPERTY)
if (TARGET Qt4::${_QT_MODULE})
foreach(_DEPEND ${ARGN})
Only add existing targets to the Qt4 target depends properties. Qt can be configured in ways which disable certain modules. Make sure we don't fail on that.
2013-02-26 21:03:04 +00:00
set(_VALID_DEPENDS)
if (TARGET Qt4::Qt${_DEPEND})
list(APPEND _VALID_DEPENDS Qt4::Qt${_DEPEND})
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
endif()
Only add existing targets to the Qt4 target depends properties. Qt can be configured in ways which disable certain modules. Make sure we don't fail on that.
2013-02-26 21:03:04 +00:00
if (_VALID_DEPENDS)
set_property(TARGET Qt4::${_QT_MODULE} APPEND PROPERTY
${_PROPERTY}
"${_VALID_DEPENDS}"
)
endif()
set(_VALID_DEPENDS)
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
endforeach()
endif()
endmacro()
macro(_qt4_add_target_depends _QT_MODULE)
FindQt4: Ensure target exists before calling get_target_property. This macro is called for all potential Qt targets, even those which were not found.
2014-01-08 09:26:49 +00:00
if (TARGET Qt4::${_QT_MODULE})
get_target_property(_configs Qt4::${_QT_MODULE} IMPORTED_CONFIGURATIONS)
_qt4_add_target_depends_internal(${_QT_MODULE} INTERFACE_LINK_LIBRARIES ${ARGN})
foreach(_config ${_configs})
_qt4_add_target_depends_internal(${_QT_MODULE} IMPORTED_LINK_INTERFACE_LIBRARIES_${_config} ${ARGN})
endforeach()
set(_configs)
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
endmacro()
macro(_qt4_add_target_private_depends _QT_MODULE)
FindQt4: Ensure target exists before calling get_target_property. This macro is called for all potential Qt targets, even those which were not found.
2014-01-08 09:26:49 +00:00
if (TARGET Qt4::${_QT_MODULE})
get_target_property(_configs Qt4::${_QT_MODULE} IMPORTED_CONFIGURATIONS)
foreach(_config ${_configs})
_qt4_add_target_depends_internal(${_QT_MODULE} IMPORTED_LINK_DEPENDENT_LIBRARIES_${_config} ${ARGN})
endforeach()
set(_configs)
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
endmacro()
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
# Set QT_xyz_LIBRARY variable and add
ENH: partly sync with KDE svn: handle QtMain more like the other libs Alex
2007-01-03 22:32:02 +00:00
# library include path to QT_INCLUDES
Qt4: Fix reference of undefined variable when detecting frameworks on Mac OS X
2011-07-25 18:30:30 +00:00
_QT4_ADJUST_LIB_VARS(QtCore)
FindQt4: Add INTERFACE includes and defines to Qt4 targets
2012-12-30 23:55:38 +00:00
set_property(TARGET Qt4::QtCore APPEND PROPERTY
INTERFACE_INCLUDE_DIRECTORIES
"${QT_MKSPECS_DIR}/default"
${QT_INCLUDE_DIR}
)
Define QT_NO_DEBUG for non-debug use of Qt 4.
2013-12-10 17:31:36 +00:00
set_property(TARGET Qt4::QtCore APPEND PROPERTY
INTERFACE_COMPILE_DEFINITIONS
$<$<NOT:$<CONFIG:Debug>>:QT_NO_DEBUG>
)
FindQt4: Set the INTERFACE_QT_MAJOR_VERSION for Qt4::QtCore With a similar commit in Qt 5, this will error at CMake time if an attempt is made to use target_link_libraries(foo Qt4::QtCore Qt5::Core)
2013-03-16 17:25:59 +00:00
set_property(TARGET Qt4::QtCore PROPERTY
INTERFACE_QT_MAJOR_VERSION 4
)
set_property(TARGET Qt4::QtCore APPEND PROPERTY
COMPATIBLE_INTERFACE_STRING QT_MAJOR_VERSION
)
Qt4: Fix reference of undefined variable when detecting frameworks on Mac OS X
2011-07-25 18:30:30 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
foreach(QT_MODULE ${QT_MODULES})
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
_QT4_ADJUST_LIB_VARS(${QT_MODULE})
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
_qt4_add_target_depends(${QT_MODULE} Core)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endforeach()
Add cross-compiling support to FindQt4.cmake
2010-07-02 21:43:38 +00:00
-make the imported targets feature of FindQt4.cmake fully backwards compatible After discussing with Brad and Clinton: -the namespace for the imported targets is now "Qt4::", tested with Makefiles, Visual Studio and XCode projects -the imported targets are always created -if QT_USE_IMPORTED_TARGETS is set to TRUE (it defaults to FALSE), the QT_QTFOO_LIBRARY variables are set to point to these imported targets, otherwise the old behaviour is used. -on OSX if Qt has been found as framework, disable QT_USE_IMPORTED_TARGETS, since cmake doesn't handle the framework directory as location of the library correctly Alex
2010-01-18 21:23:21 +00:00
_QT4_ADJUST_LIB_VARS(QtAssistant)
_QT4_ADJUST_LIB_VARS(QtAssistantClient)
_QT4_ADJUST_LIB_VARS(QtCLucene)
_QT4_ADJUST_LIB_VARS(QtDesignerComponents)
Add documentation for Cocoa flag and move Motif under X11 flag.
2009-10-01 20:41:00 +00:00
# platform dependent libraries
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Q_WS_WIN)
-make the imported targets feature of FindQt4.cmake fully backwards compatible After discussing with Brad and Clinton: -the namespace for the imported targets is now "Qt4::", tested with Makefiles, Visual Studio and XCode projects -the imported targets are always created -if QT_USE_IMPORTED_TARGETS is set to TRUE (it defaults to FALSE), the QT_QTFOO_LIBRARY variables are set to point to these imported targets, otherwise the old behaviour is used. -on OSX if Qt has been found as framework, disable QT_USE_IMPORTED_TARGETS, since cmake doesn't handle the framework directory as location of the library correctly Alex
2010-01-18 21:23:21 +00:00
_QT4_ADJUST_LIB_VARS(qtmain)
Automatically link to the qtmain library when linking to QtCore. When using QAxServer, ensure that the qtmain library is excluded by reporting an error at CMake time if it is not.
2012-11-20 13:53:41 +00:00
FindQt4: Don't use Qt component _FOUND vars before they're defined (#14286) This fixes a regression introduced by commit b8af46cb (FindQt4: Don't fail if certain Qt modules are unavailable., 2013-05-23) The _FOUND variable is set by the _QT4_ADJUST_LIB_VARS macro, so invoke that unconditionally, and guard only the set_property calls, as described in the original bug report (#14165).
2013-07-22 12:27:22 +00:00
_QT4_ADJUST_LIB_VARS(QAxServer)
FindQt4: Don't fail if certain Qt modules are unavailable.
2013-05-23 15:02:05 +00:00
if(QT_QAXSERVER_FOUND)
set_property(TARGET Qt4::QAxServer PROPERTY
INTERFACE_QT4_NO_LINK_QTMAIN ON
)
set_property(TARGET Qt4::QAxServer APPEND PROPERTY
COMPATIBLE_INTERFACE_BOOL QT4_NO_LINK_QTMAIN)
endif()
Automatically link to the qtmain library when linking to QtCore. When using QAxServer, ensure that the qtmain library is excluded by reporting an error at CMake time if it is not.
2012-11-20 13:53:41 +00:00
FindQt4: Don't use Qt component _FOUND vars before they're defined (#14286) This fixes a regression introduced by commit b8af46cb (FindQt4: Don't fail if certain Qt modules are unavailable., 2013-05-23) The _FOUND variable is set by the _QT4_ADJUST_LIB_VARS macro, so invoke that unconditionally, and guard only the set_property calls, as described in the original bug report (#14165).
2013-07-22 12:27:22 +00:00
_QT4_ADJUST_LIB_VARS(QAxContainer)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
-better support for Qt4 as frameworks before this patch -F<framework> dir had to be added manually in some way when using Qt4 installed as framework and when using FindQt4.cmake directly, i.e. without UseQt4.cmake. With this patch the framework dir is automatically added to QT_INCLUDE_DIR when Qt is installed as a framework. Ok by Clinton, tested already in KDE by Mike Arthur. Alex
2009-12-16 22:16:59 +00:00
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
# Only public dependencies are listed here.
# Eg, QtDBus links to QtXml, but users of QtDBus do not need to
# link to QtXml because QtDBus only uses it internally, not in public
# headers.
# Everything depends on QtCore, but that is covered above already
_qt4_add_target_depends(Qt3Support Sql Gui Network)
FindQt4: Add INTERFACE includes and defines to Qt4 targets
2012-12-30 23:55:38 +00:00
if (TARGET Qt4::Qt3Support)
# An additional define is required for QT3_SUPPORT
set_property(TARGET Qt4::Qt3Support APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS QT3_SUPPORT)
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
_qt4_add_target_depends(QtDeclarative Script Gui)
_qt4_add_target_depends(QtDesigner Gui)
_qt4_add_target_depends(QtHelp Gui)
_qt4_add_target_depends(QtMultimedia Gui)
_qt4_add_target_depends(QtOpenGL Gui)
_qt4_add_target_depends(QtSvg Gui)
_qt4_add_target_depends(QtWebKit Gui Network)
_qt4_add_target_private_depends(Qt3Support Xml)
FindQt4: Don't fail if certain Qt modules are unavailable.
2013-05-23 15:02:05 +00:00
if(QT_VERSION VERSION_GREATER 4.6)
_qt4_add_target_private_depends(QtSvg Xml)
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
_qt4_add_target_private_depends(QtDBus Xml)
_qt4_add_target_private_depends(QtUiTools Xml Gui)
_qt4_add_target_private_depends(QtHelp Sql Xml Network)
_qt4_add_target_private_depends(QtXmlPatterns Network)
_qt4_add_target_private_depends(QtScriptTools Gui)
_qt4_add_target_private_depends(QtWebKit XmlPatterns)
_qt4_add_target_private_depends(QtDeclarative XmlPatterns Svg Sql Gui)
_qt4_add_target_private_depends(QtMultimedia Gui)
_qt4_add_target_private_depends(QtOpenGL Gui)
FindQt4: Don't fail if certain Qt modules are unavailable.
2013-05-23 15:02:05 +00:00
if(QT_QAXSERVER_FOUND)
_qt4_add_target_private_depends(QAxServer Gui)
endif()
if(QT_QAXCONTAINER_FOUND)
_qt4_add_target_private_depends(QAxContainer Gui)
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 08:41:09 +00:00
_qt4_add_target_private_depends(phonon Gui)
if(QT_QTDBUS_FOUND)
_qt4_add_target_private_depends(phonon DBus)
endif()
ENH: fixes from Clinton to allow qt to work with static libs
2006-09-06 12:31:50 +00:00
Automatically link to the qtmain library when linking to QtCore. When using QAxServer, ensure that the qtmain library is excluded by reporting an error at CMake time if it is not.
2012-11-20 13:53:41 +00:00
if (WIN32 AND NOT QT4_NO_LINK_QTMAIN)
set(_isExe $<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>)
set(_isWin32 $<BOOL:$<TARGET_PROPERTY:WIN32_EXECUTABLE>>)
set(_isNotExcluded $<NOT:$<BOOL:$<TARGET_PROPERTY:QT4_NO_LINK_QTMAIN>>>)
set(_isPolicyNEW $<TARGET_POLICY:CMP0020>)
Generate config-specific interface link libraries propeties. All other properties we generate are config-specific, so it makes sense to do so here too.
2013-02-09 09:20:14 +00:00
get_target_property(_configs Qt4::QtCore IMPORTED_CONFIGURATIONS)
FindQt4: Populate the INTERFACE_LINK_LIBRARIES of IMPORTED targets. This makes the IMPORTED_LINK_INTERFACE_LIBRARIES_<CONFIG> properties obsolete.
2013-07-25 09:19:22 +00:00
set_property(TARGET Qt4::QtCore APPEND PROPERTY
INTERFACE_LINK_LIBRARIES
$<$<AND:${_isExe},${_isWin32},${_isNotExcluded},${_isPolicyNEW}>:Qt4::qtmain>
)
Generate config-specific interface link libraries propeties. All other properties we generate are config-specific, so it makes sense to do so here too.
2013-02-09 09:20:14 +00:00
foreach(_config ${_configs})
set_property(TARGET Qt4::QtCore APPEND PROPERTY
IMPORTED_LINK_INTERFACE_LIBRARIES_${_config}
$<$<AND:${_isExe},${_isWin32},${_isNotExcluded},${_isPolicyNEW}>:Qt4::qtmain>
)
endforeach()
unset(_configs)
Automatically link to the qtmain library when linking to QtCore. When using QAxServer, ensure that the qtmain library is excluded by reporting an error at CMake time if it is not.
2012-11-20 13:53:41 +00:00
unset(_isExe)
unset(_isWin32)
unset(_isNotExcluded)
unset(_isPolicyNEW)
endif()
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
#######################################
#
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
# Check the executables of Qt
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
# ( moc, uic, rcc )
#
#######################################
ENH: add new qt stuff from warfield@bwh.harvard.edu, thanks
2005-07-15 16:14:47 +00:00
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(QT_QMAKE_CHANGED)
set(QT_UIC_EXECUTABLE NOTFOUND)
set(QT_MOC_EXECUTABLE NOTFOUND)
set(QT_UIC3_EXECUTABLE NOTFOUND)
set(QT_RCC_EXECUTABLE NOTFOUND)
set(QT_DBUSCPP2XML_EXECUTABLE NOTFOUND)
set(QT_DBUSXML2CPP_EXECUTABLE NOTFOUND)
set(QT_LUPDATE_EXECUTABLE NOTFOUND)
set(QT_LRELEASE_EXECUTABLE NOTFOUND)
set(QT_QCOLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
set(QT_DESIGNER_EXECUTABLE NOTFOUND)
set(QT_LINGUIST_EXECUTABLE NOTFOUND)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
Qt4: Create IMPORTED executable targets for all Qt executables. Qt 5 already has similar IMPORTED targets. The versioned namespace will allow de-conflicting the variable names between Qt 4 and Qt 5.
2014-01-24 11:55:21 +00:00
macro(_find_qt4_program VAR NAME)
find_program(${VAR}
NAMES ${ARGN}
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
)
if (${VAR} AND NOT TARGET ${NAME})
add_executable(${NAME} IMPORTED)
set_property(TARGET ${NAME} PROPERTY IMPORTED_LOCATION ${${VAR}})
endif()
endmacro()
also provide QT_DESIGNER_EXECUTABLE and QT_LINGUIST_EXECUTABLE Alex
2009-11-23 22:53:50 +00:00
FindQt[34]: Prefer matching versioned tool names After finding qmake we search in QT_BINARY_DIR for the other Qt tools. Try all versioned executable names before trying the plain executable name. This makes it much more likely that if 2 different major versions are installed in the same prefix CMake will be able to detect a proper set of tools.
2014-05-20 15:47:54 +00:00
_find_qt4_program(QT_MOC_EXECUTABLE Qt4::moc moc-qt4 moc4 moc)
_find_qt4_program(QT_UIC_EXECUTABLE Qt4::uic uic-qt4 uic4 uic)
Qt4: Create IMPORTED executable targets for all Qt executables. Qt 5 already has similar IMPORTED targets. The versioned namespace will allow de-conflicting the variable names between Qt 4 and Qt 5.
2014-01-24 11:55:21 +00:00
_find_qt4_program(QT_UIC3_EXECUTABLE Qt4::uic3 uic3)
_find_qt4_program(QT_RCC_EXECUTABLE Qt4::rcc rcc)
_find_qt4_program(QT_DBUSCPP2XML_EXECUTABLE Qt4::qdbuscpp2xml qdbuscpp2xml)
_find_qt4_program(QT_DBUSXML2CPP_EXECUTABLE Qt4::qdbusxml2cpp qdbusxml2cpp)
FindQt[34]: Prefer matching versioned tool names After finding qmake we search in QT_BINARY_DIR for the other Qt tools. Try all versioned executable names before trying the plain executable name. This makes it much more likely that if 2 different major versions are installed in the same prefix CMake will be able to detect a proper set of tools.
2014-05-20 15:47:54 +00:00
_find_qt4_program(QT_LUPDATE_EXECUTABLE Qt4::lupdate lupdate-qt4 lupdate4 lupdate)
_find_qt4_program(QT_LRELEASE_EXECUTABLE Qt4::lrelease lrelease-qt4 lrelease4 lrelease)
Qt4: Create IMPORTED executable targets for all Qt executables. Qt 5 already has similar IMPORTED targets. The versioned namespace will allow de-conflicting the variable names between Qt 4 and Qt 5.
2014-01-24 11:55:21 +00:00
_find_qt4_program(QT_QCOLLECTIONGENERATOR_EXECUTABLE Qt4::qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator)
FindQt[34]: Prefer matching versioned tool names After finding qmake we search in QT_BINARY_DIR for the other Qt tools. Try all versioned executable names before trying the plain executable name. This makes it much more likely that if 2 different major versions are installed in the same prefix CMake will be able to detect a proper set of tools.
2014-05-20 15:47:54 +00:00
_find_qt4_program(QT_DESIGNER_EXECUTABLE Qt4::designer designer-qt4 designer4 designer)
_find_qt4_program(QT_LINGUIST_EXECUTABLE Qt4::linguist linguist-qt4 linguist4 linguist)
also provide QT_DESIGNER_EXECUTABLE and QT_LINGUIST_EXECUTABLE Alex
2009-11-23 22:53:50 +00:00
Qt4: Add IMPORTED executable for qmake.
2014-02-09 13:35:57 +00:00
if (NOT TARGET Qt4::qmake)
add_executable(Qt4::qmake IMPORTED)
set_property(TARGET Qt4::qmake PROPERTY IMPORTED_LOCATION ${QT_QMAKE_EXECUTABLE})
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_MOC_EXECUTABLE)
set(QT_WRAP_CPP "YES")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (QT_UIC_EXECUTABLE)
set(QT_WRAP_UI "YES")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
mark_as_advanced( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE
ENH: Make lupdate and lrelease executables advanced variables.
2008-01-29 22:01:00 +00:00
QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE
also provide QT_DESIGNER_EXECUTABLE and QT_LINGUIST_EXECUTABLE Alex
2009-11-23 22:53:50 +00:00
QT_LUPDATE_EXECUTABLE QT_LRELEASE_EXECUTABLE QT_QCOLLECTIONGENERATOR_EXECUTABLE
QT_DESIGNER_EXECUTABLE QT_LINGUIST_EXECUTABLE)
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 18:02:19 +00:00
# get the directory of the current file, used later on in the file
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
get_filename_component( _qt4_current_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 18:02:19 +00:00
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
ENH: fixes from Clinton to allow qt to work with static libs
2006-09-06 12:31:50 +00:00
###############################################
#
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 17:42:58 +00:00
# configuration/system dependent settings
ENH: fixes from Clinton to allow qt to work with static libs
2006-09-06 12:31:50 +00:00
#
###############################################
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
include("${_qt4_current_dir}/Qt4ConfigDependentSettings.cmake")
ENH: For Mac OS X, remove QuickTime link for Qt 4.3+ and add AppKit link for Qt 4.2+.
2008-03-17 18:53:02 +00:00
ENH: make sure the correct qmake is used
2005-09-12 13:00:55 +00:00
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
#######################################
#
# Check the plugins of Qt
#
#######################################
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set( QT_PLUGIN_TYPES accessible bearer codecs decorations designer gfxdrivers graphicssystems iconengines imageformats inputmethods mousedrivers phonon_backend script sqldrivers )
set( QT_ACCESSIBLE_PLUGINS qtaccessiblecompatwidgets qtaccessiblewidgets )
FindQt4: Add nativewifi and qtga plugins While at it, update QT_QTGUI_PLUGINS to use QT_IMAGEFORMATS_PLUGINS instead of duplicating the list.
2014-07-24 07:46:26 +00:00
set( QT_BEARER_PLUGINS qcorewlanbearer qgenericbearer qnativewifibearer )
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set( QT_CODECS_PLUGINS qcncodecs qjpcodecs qkrcodecs qtwcodecs )
set( QT_DECORATIONS_PLUGINS qdecorationdefault qdecorationwindows )
set( QT_DESIGNER_PLUGINS arthurplugin containerextension customwidgetplugin phononwidgets qdeclarativeview qt3supportwidgets qwebview taskmenuextension worldtimeclockplugin )
set( QT_GRAPHICSDRIVERS_PLUGINS qgfxtransformed qgfxvnc qscreenvfb )
set( QT_GRAPHICSSYSTEMS_PLUGINS qglgraphicssystem qtracegraphicssystem )
set( QT_ICONENGINES_PLUGINS qsvgicon )
FindQt4: Add nativewifi and qtga plugins While at it, update QT_QTGUI_PLUGINS to use QT_IMAGEFORMATS_PLUGINS instead of duplicating the list.
2014-07-24 07:46:26 +00:00
set( QT_IMAGEFORMATS_PLUGINS qgif qjpeg qmng qico qsvg qtiff qtga )
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set( QT_INPUTMETHODS_PLUGINS qimsw_multi )
set( QT_MOUSEDRIVERS_PLUGINS qwstslibmousehandler )
if(APPLE)
set( QT_PHONON_BACKEND_PLUGINS phonon_qt7 )
elseif(WIN32)
set( QT_PHONON_BACKEND_PLUGINS phonon_ds9 )
endif()
set( QT_SCRIPT_PLUGINS qtscriptdbus )
set( QT_SQLDRIVERS_PLUGINS qsqldb2 qsqlibase qsqlite qsqlite2 qsqlmysql qsqloci qsqlodbc qsqlpsql qsqltds )
set( QT_PHONON_PLUGINS ${QT_PHONON_BACKEND_PLUGINS} )
set( QT_QT3SUPPORT_PLUGINS qtaccessiblecompatwidgets )
set( QT_QTCORE_PLUGINS ${QT_BEARER_PLUGINS} ${QT_CODECS_PLUGINS} )
FindQt4: Add nativewifi and qtga plugins While at it, update QT_QTGUI_PLUGINS to use QT_IMAGEFORMATS_PLUGINS instead of duplicating the list.
2014-07-24 07:46:26 +00:00
set( QT_QTGUI_PLUGINS qtaccessiblewidgets ${QT_IMAGEFORMATS_PLUGINS} ${QT_DECORATIONS_PLUGINS} ${QT_GRAPHICSDRIVERS_PLUGINS} ${QT_GRAPHICSSYSTEMS_PLUGINS} ${QT_INPUTMETHODS_PLUGINS} ${QT_MOUSEDRIVERS_PLUGINS} )
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set( QT_QTSCRIPT_PLUGINS ${QT_SCRIPT_PLUGINS} )
set( QT_QTSQL_PLUGINS ${QT_SQLDRIVERS_PLUGINS} )
set( QT_QTSVG_PLUGINS qsvg qsvgicon )
if(QT_QMAKE_CHANGED)
foreach(QT_PLUGIN_TYPE ${QT_PLUGIN_TYPES})
string(TOUPPER ${QT_PLUGIN_TYPE} _upper_qt_plugin_type)
set(QT_${_upper_qt_plugin_type}_PLUGINS_DIR ${QT_PLUGINS_DIR}/${QT_PLUGIN_TYPE})
foreach(QT_PLUGIN ${QT_${_upper_qt_plugin_type}_PLUGINS})
string(TOUPPER ${QT_PLUGIN} _upper_qt_plugin)
unset(QT_${_upper_qt_plugin}_LIBRARY_RELEASE CACHE)
unset(QT_${_upper_qt_plugin}_LIBRARY_DEBUG CACHE)
unset(QT_${_upper_qt_plugin}_LIBRARY CACHE)
unset(QT_${_upper_qt_plugin}_PLUGIN_RELEASE CACHE)
unset(QT_${_upper_qt_plugin}_PLUGIN_DEBUG CACHE)
unset(QT_${_upper_qt_plugin}_PLUGIN CACHE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endforeach()
endforeach()
endif()
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
# find_library works better than find_file but we need to set prefixes to only match plugins
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
foreach(QT_PLUGIN_TYPE ${QT_PLUGIN_TYPES})
string(TOUPPER ${QT_PLUGIN_TYPE} _upper_qt_plugin_type)
set(QT_${_upper_qt_plugin_type}_PLUGINS_DIR ${QT_PLUGINS_DIR}/${QT_PLUGIN_TYPE})
foreach(QT_PLUGIN ${QT_${_upper_qt_plugin_type}_PLUGINS})
string(TOUPPER ${QT_PLUGIN} _upper_qt_plugin)
if(QT_IS_STATIC)
find_library(QT_${_upper_qt_plugin}_LIBRARY_RELEASE
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
NAMES ${QT_PLUGIN}${QT_LIBINFIX} ${QT_PLUGIN}${QT_LIBINFIX}4
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_${_upper_qt_plugin}_LIBRARY_DEBUG
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
NAMES ${QT_PLUGIN}${QT_LIBINFIX}_debug ${QT_PLUGIN}${QT_LIBINFIX}d ${QT_PLUGIN}${QT_LIBINFIX}d4
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
)
_QT4_ADJUST_LIB_VARS(${QT_PLUGIN})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
# find_library works easier/better than find_file but we need to set suffixes to only match plugins
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(CMAKE_FIND_LIBRARY_SUFFIXES_DEFAULT ${CMAKE_FIND_LIBRARY_SUFFIXES})
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_MODULE_SUFFIX} ${CMAKE_SHARED_LIBRARY_SUFFIX})
find_library(QT_${_upper_qt_plugin}_PLUGIN_RELEASE
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
NAMES ${QT_PLUGIN}${QT_LIBINFIX} ${QT_PLUGIN}${QT_LIBINFIX}4
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(QT_${_upper_qt_plugin}_PLUGIN_DEBUG
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
NAMES ${QT_PLUGIN}${QT_LIBINFIX}_debug ${QT_PLUGIN}${QT_LIBINFIX}d ${QT_PLUGIN}${QT_LIBINFIX}d4
When cross compiling, don't double-root paths when using find_*.
2011-03-10 21:17:13 +00:00
PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
mark_as_advanced(QT_${_upper_qt_plugin}_PLUGIN_RELEASE QT_${_upper_qt_plugin}_PLUGIN_DEBUG)
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_DEFAULT})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endforeach()
endforeach()
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
######################################
#
# Macros for building Qt files
#
######################################
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
include("${_qt4_current_dir}/Qt4Macros.cmake")
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Add support for using static/dynamic Qt plugins.
2011-01-01 18:45:05 +00:00
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
#support old QT_MIN_VERSION if set, but not if version is supplied by find_package()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT Qt4_FIND_VERSION AND QT_MIN_VERSION)
set(Qt4_FIND_VERSION ${QT_MIN_VERSION})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if( Qt4_FIND_COMPONENTS )
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
# if components specified in find_package(), make sure each of those pieces were found
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(_QT4_FOUND_REQUIRED_VARS QT_QMAKE_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_INCLUDE_DIR QT_LIBRARY_DIR)
foreach( component ${Qt4_FIND_COMPONENTS} )
string( TOUPPER ${component} _COMPONENT )
When checking find_package() components, special case qtmain. Its just a library on Windows only. Fixes bug #11791.
2011-02-03 23:37:04 +00:00
if(${_COMPONENT} STREQUAL "QTMAIN")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Q_WS_WIN)
set(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_${_COMPONENT}_LIBRARY)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_${_COMPONENT}_INCLUDE_DIR QT_${_COMPONENT}_LIBRARY)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endforeach()
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
if(Qt4_FIND_COMPONENTS MATCHES QtGui)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_UIC_EXECUTABLE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
# if no components specified, we'll make a default set of required variables to say Qt is found
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(_QT4_FOUND_REQUIRED_VARS QT_QMAKE_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_UIC_EXECUTABLE QT_INCLUDE_DIR
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
QT_LIBRARY_DIR QT_QTCORE_LIBRARY)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
FindQt4: Do not use qmake from Qt5 Wihtout this, if qmake binary is from Qt5 the FindQt4 fails even though the Qt4 version of qmake would be installed as qmake-qt4. On Archlinux this is the case. Reviewed-by: Clinton Stimpson <clinton@elemtech.com>
2013-03-05 16:32:55 +00:00
if (NOT QT_VERSION_MAJOR EQUAL 4)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(VERSION_MSG "Found unsuitable Qt version \"${QTVERSION}\" from ${QT_QMAKE_EXECUTABLE}")
FindQt4: Fix handling of QT_VERSION_MAJOR mismatch Fix capitalization of Qt4_FOUND variable when setting it to false in this case. This caused find_package(Qt4) to appear successful when it was not. Note that the legacy QT4_FOUND variable is unconditionally overwritten at the end of the file with the value of Qt4_FOUND.
2014-12-09 14:40:45 +00:00
set(Qt4_FOUND FALSE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(Qt4_FIND_REQUIRED)
message( FATAL_ERROR "${VERSION_MSG}, this code requires Qt 4.x")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT Qt4_FIND_QUIETLY)
message( STATUS "${VERSION_MSG}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif()
Abort FindQt4.cmake if Qt 5 is found.
2012-05-03 14:46:50 +00:00
else()
FindQt4: Set the Qt4_FOUND variable if Qt4 is found Provide the old QT4_FOUND for compatibility.
2013-03-16 17:42:14 +00:00
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Qt4 FOUND_VAR Qt4_FOUND
Abort FindQt4.cmake if Qt 5 is found.
2012-05-03 14:46:50 +00:00
REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS}
VERSION_VAR QTVERSION
)
endif()
Change to use fphsa to check required variables and version. Also, set the required variables based on components, if specified. Also, don't make finding uic required if not using QtGui.
2011-01-15 04:26:19 +00:00
#######################################
#
# compatibility settings
#
#######################################
# Backwards compatibility for CMake1.4 and 1.2
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
set (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
set( QT_QT_LIBRARY "")
FindQt4: Set the Qt4_FOUND variable if Qt4 is found Provide the old QT4_FOUND for compatibility.
2013-03-16 17:42:14 +00:00
set(QT4_FOUND ${Qt4_FOUND})
set(QT_FOUND ${Qt4_FOUND})
ENH: -apply the patches by Clinton Stimpson and Kenneth Moreland which fix some QtMain issues on Windows ENH: -sync with KDE svn FindQt4, which features a lot of enhancements Alex
2006-04-27 19:07:23 +00:00
Reference in New Issue Copy Permalink