mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-03-03 13:18:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge topic 'autogen_json'

Browse Source 
29d96633 Autogen: Don't use .moc include in Q_PLUGIN_METADATA test
d60f1ddc Autogen: Documentation update
cdb72127 Autogen: Add release notes for Q_PLUGIN_METADATA support
8b13a52c Autogen: Tests: Set different compression levels in rcc test
9d1db7d7 Autogen: Overhaul and simplify AutogenInfo.cmake file generation
0ab817fa Autogen: Optimize GetCompileDefinitionsAndDirectories function
754d4318 Autogen: Sort AutogenInfo.cmake.in
cd74daf0 Autogen: Tests: Add Q_PLUGIN_METADATA test
39c4819e Autogen: Tests: Add moc include tests
50805693 Autogen: Tests: Clean comments
c23206b6 Autogen: Log simplifications
347572cf Autogen: Only touch an unchanged moc_compilation.cpp
03df033b Autogen: Rebuild moc when Q_PLUGIN_METADATA json file changes
3ec230de Autogen: Use GetRealPath in central places only
41fb64e7 Autogen: Search moc includes in include directories
175c8900 Autogen: Sort includes before composing include options
...
This commit is contained in:
Brad King
2017-02-22 10:15:48 -05:00
committed by CMake Topic Stage
parent dc32ad1988 29d96633a4
commit dfebdd6218
45 changed files with 1971 additions and 1186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Help/manual/cmake-qt.7.rst
View File

@@ -63,20 +63,24 @@ If a ``Q_OBJECT`` or ``Q_GADGET`` macro is found in a header file, ``moc``
will be run on the file. The result will be put into a file named according
to ``moc_<basename>.cpp``. If the macro is found in a C++ implementation
file, the moc output will be put into a file named according to
``<basename>.moc``, following the Qt conventions. The ``moc file`` may be
included by the user in the C++ implementation file with a preprocessor
``#include``. If it is not so included, it will be added to a separate file
which is compiled into the target.
``<basename>.moc``, following the Qt conventions. The ``<basename>.moc`` must
be included by the user in the C++ implementation file with a preprocessor
``#include``.
Included ``moc_*.cpp`` and ``*.moc`` files will be generated in the
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory which is
automatically added to the target's :prop_tgt:`INCLUDE_DIRECTORIES`.
(This differs from CMake 3.7 and below; see their documentation for details.)
Not included ``moc_<basename>.cpp`` files will be generated in custom
folders to avoid name collisions and included in a separate
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/moc_compilation.cpp``
file which is compiled into the target.
The ``moc`` command line will consume the :prop_tgt:`COMPILE_DEFINITIONS` and
:prop_tgt:`INCLUDE_DIRECTORIES` target properties from the target it is being
invoked for, and for the appropriate build configuration.
The generated ``moc_*.cpp`` and ``*.moc`` files are placed in the
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory which is
automatically added to the target's :prop_tgt:`INCLUDE_DIRECTORIES`.
(This differs from CMake 3.7 and below; see their documentation for details.)
The :prop_tgt:`AUTOMOC` target property may be pre-set for all
following targets by setting the :variable:`CMAKE_AUTOMOC` variable. The
:prop_tgt:`AUTOMOC_MOC_OPTIONS` target property may be populated to set

52
Help/prop_tgt/AUTOMOC.rst
View File

@@ -8,31 +8,41 @@ preprocessor automatically, i.e. without having to use the
:module:`QT4_WRAP_CPP() <FindQt4>` or QT5_WRAP_CPP() macro. Currently Qt4 and Qt5 are
supported.
When this property is set ``ON``, CMake will scan the
When this property is set ``ON``, CMake will scan the header and
source files at build time and invoke moc accordingly.
* If an ``#include`` statement like ``#include "moc_foo.cpp"`` is found,
the ``Q_OBJECT`` class declaration is expected in the header, and
``moc`` is run on the header file. A ``moc_foo.cpp`` file will be
generated from the source's header into the
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include``
directory which is automatically added to the target's
* If an ``#include`` statement like ``#include "moc_<basename>.cpp"`` is found,
the ``Q_OBJECT`` or ``Q_GADGET`` macros are expected in an otherwise empty
line of the ``<basename>.h(xx)`` header file. ``moc`` is run on the header file to
generate ``moc_<basename>.cpp`` in the
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory
which is automatically added to the target's
:prop_tgt:`INCLUDE_DIRECTORIES`. This allows the compiler to find the
included ``moc_foo.cpp`` file regardless of the location the original source.
However, if multiple source files in different directories do this then their
generated moc files would collide. In this case a diagnostic will be issued.
included ``moc_<basename>.cpp`` file regardless of the location the
original source.
* If an ``#include`` statement like ``#include "foo.moc"`` is found,
then a ``Q_OBJECT`` is expected in the current source file and ``moc``
is run on the file itself. Additionally, header files with the same
base name (like ``foo.h``) or ``_p`` appended to the base name (like
``foo_p.h``) are parsed for ``Q_OBJECT`` macros, and if found, ``moc``
is also executed on those files. ``AUTOMOC`` checks multiple header
alternative extensions, such as ``hpp``, ``hxx`` etc when searching
for headers. The resulting moc files, which are not included as shown
above in any of the source files are included in a generated
``moc_compilation.cpp`` file, which is compiled as part of the
target.
* If an ``#include`` statement like ``#include "<basename>.moc"`` is found,
then ``Q_OBJECT`` or ``Q_GADGET`` macros are expected in the current source
file and ``moc`` is run on the source file itself.
* Header files that are not included by an ``#include "moc_<basename>.cpp"``
statement are nonetheless scanned for ``Q_OBJECT`` or ``Q_GADGET`` macros.
The resulting ``moc_<basename>.cpp`` files are generated in custom
directories and automatically included in the generated
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/moc_compilation.cpp`` file,
which is compiled as part of the target. The custom directories help to
avoid name collisions for moc files with the same ``<basename>``.
* Additionally, header files with the same base name as a source file,
(like ``<basename>.h``) or ``_p`` appended to the base name (like
``<basename>_p.h``), are parsed for ``Q_OBJECT`` or ``Q_GADGET`` macros,
and if found, ``moc`` is also executed on those files.
* ``AUTOMOC`` always checks multiple header alternative extensions,
such as ``hpp``, ``hxx``, etc. when searching for headers.
* ``AUTOMOC`` looks for the ``Q_PLUGIN_METADATA`` macro and reruns the
``moc`` when the file addressed by the ``FILE`` argument of the macro changes.
This property is initialized by the value of the :variable:`CMAKE_AUTOMOC`
variable if it is set when a target is created.

10
Help/release/dev/Autogen_json.rst Normal file
View File

@@ -0,0 +1,10 @@
AutoGen json
------------
* When using :prop_tgt:`AUTOMOC`, CMake scans for the presence of the
``Q_PLUGIN_METADATA`` macro and reruns moc when the file from the
macro's ``FILE`` argument changes.
* When :prop_tgt:`AUTOMOC` detects an include statement of the form
``#include "moc_<basename>.cpp"`` the respective header file is searched
for in the :prop_tgt:`INCLUDE_DIRECTORIES` of the target as well.

38
Modules/AutogenInfo.cmake.in
View File

@@ -1,25 +1,31 @@
set(AM_SOURCES @_moc_uic_sources@)
set(AM_HEADERS @_moc_uic_headers@)
set(AM_SKIP_MOC @_skip_moc@)
set(AM_SKIP_UIC @_skip_uic@)
# Target names
set(AM_TARGET_NAME @_autogen_target_name@)
set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
# Directories and files
set(AM_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@/")
set(AM_CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@/")
set(AM_CMAKE_CURRENT_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@/")
set(AM_CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/")
set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
set(AM_SOURCES @_sources@)
set(AM_HEADERS @_headers@)
# Qt environment
set(AM_QT_VERSION_MAJOR @_qt_version_major@)
set(AM_QT_MOC_EXECUTABLE @_qt_moc_executable@)
set(AM_QT_UIC_EXECUTABLE @_qt_uic_executable@)
set(AM_QT_RCC_EXECUTABLE @_qt_rcc_executable@)
# MOC settings
set(AM_MOC_SKIP @_moc_skip@)
set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
set(AM_MOC_INCLUDES @_moc_incs@)
set(AM_MOC_OPTIONS @_moc_options@)
set(AM_MOC_RELAXED_MODE "@_moc_relaxed_mode@")
set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
set(AM_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@/")
set(AM_CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@/")
set(AM_QT_MOC_EXECUTABLE "@_qt_moc_executable@")
set(AM_QT_UIC_EXECUTABLE "@_qt_uic_executable@")
set(AM_QT_RCC_EXECUTABLE "@_qt_rcc_executable@")
set(AM_CMAKE_CURRENT_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@/")
set(AM_CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/")
set(AM_QT_VERSION_MAJOR "@_target_qt_version@")
set(AM_TARGET_NAME @_moc_target_name@)
set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
set(AM_MOC_RELAXED_MODE @_moc_relaxed_mode@)
# UIC settings
set(AM_UIC_SKIP @_uic_skip@)
set(AM_UIC_TARGET_OPTIONS @_uic_target_options@)
set(AM_UIC_OPTIONS_FILES @_qt_uic_options_files@)
set(AM_UIC_OPTIONS_OPTIONS @_qt_uic_options_options@)
# RCC settings
set(AM_RCC_SOURCES @_rcc_files@ )
set(AM_RCC_INPUTS @_rcc_inputs@)
set(AM_RCC_OPTIONS_FILES @_rcc_options_files@)

4
Source/cmFilePathChecksum.cxx
View File

@@ -45,7 +45,7 @@ void cmFilePathChecksum::setupParentDirs(const std::string& currentSrcDir,
parentDirs[3].second = "ProjectBinary";
}
std::string cmFilePathChecksum::get(const std::string& filePath)
std::string cmFilePathChecksum::get(const std::string& filePath) const
{
std::string relPath;
std::string relSeed;
@@ -82,7 +82,7 @@ std::string cmFilePathChecksum::get(const std::string& filePath)
}
std::string cmFilePathChecksum::getPart(const std::string& filePath,
size_t length)
size_t length) const
{
return get(filePath).substr(0, length);
}

4
Source/cmFilePathChecksum.h
View File

@@ -47,13 +47,13 @@ public:
/* @brief Calculates the path checksum for the parent directory of a file
*
*/
std::string get(const std::string& filePath);
std::string get(const std::string& filePath) const;
/* @brief Same as get() but returns only the first length characters
*
*/
std::string getPart(const std::string& filePath,
size_t length = partLengthDefault);
size_t length = partLengthDefault) const;
private:
/// Size of the parent directory list

667
Source/cmQtAutoGeneratorInitializer.cxx
View File

@@ -22,7 +22,6 @@
#endif
#include <algorithm>
#include <assert.h>
#include <cmConfigure.h>
#include <cmsys/FStream.hxx>
#include <cmsys/RegularExpression.hxx>
@@ -55,6 +54,13 @@ static std::string utilStripCR(std::string const& line)
return line;
}
static std::string GetSafeProperty(cmGeneratorTarget const* target,
const char* key)
{
const char* tmp = target->GetProperty(key);
return std::string((tmp != CM_NULLPTR) ? tmp : "");
}
static std::string GetAutogenTargetName(cmGeneratorTarget const* target)
{
std::string autogenTargetName = target->GetName();
@@ -98,19 +104,53 @@ static std::string GetQtMajorVersion(cmGeneratorTarget const* target)
return qtMajorVersion;
}
static void GetCompileDefinitionsAndDirectories(
cmGeneratorTarget const* target, const std::string& config,
std::string& incs, std::string& defs)
{
cmLocalGenerator* localGen = target->GetLocalGenerator();
{
std::vector<std::string> includeDirs;
// Get the include dirs for this target, without stripping the implicit
// include dirs off, see
// https://gitlab.kitware.com/cmake/cmake/issues/13667
localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
incs = cmJoin(includeDirs, ";");
}
{
std::set<std::string> defines;
localGen->AddCompileDefinitions(defines, target, config, "CXX");
defs += cmJoin(defines, ";");
}
}
static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
const std::string& value)
{
makefile->AddDefinition(key,
cmOutputConverter::EscapeForCMake(value).c_str());
}
static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
const std::vector<std::string>& values)
{
makefile->AddDefinition(
key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
}
static void SetupSourceFiles(cmGeneratorTarget const* target,
std::vector<std::string>& mocUicSources,
std::vector<std::string>& mocUicHeaders,
std::vector<std::string>& skipMocList,
std::vector<std::string>& skipUicList)
std::vector<std::string>& mocSkipList,
std::vector<std::string>& uicSkipList)
{
cmMakefile* makefile = target->Target->GetMakefile();
std::vector<cmSourceFile*> srcFiles;
target->GetConfigCommonSourceFiles(srcFiles);
const bool targetMoc = target->GetPropertyAsBool("AUTOMOC");
const bool targetUic = target->GetPropertyAsBool("AUTOUIC");
const bool mocTarget = target->GetPropertyAsBool("AUTOMOC");
const bool uicTarget = target->GetPropertyAsBool("AUTOUIC");
cmFilePathChecksum fpathCheckSum(makefile);
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
@@ -131,22 +171,22 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
// Skip flags
const bool skipAll =
cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOGEN"));
const bool skipMoc =
const bool mocSkip =
skipAll || cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
const bool skipUic =
const bool uicSkip =
skipAll || cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"));
// Add file name to skip lists.
// Do this even when the file is not added to the sources/headers lists
// because the file name may be extracted from an other file when
// processing
if (skipMoc) {
skipMocList.push_back(absFile);
if (mocSkip) {
mocSkipList.push_back(absFile);
}
if (skipUic) {
skipUicList.push_back(absFile);
if (uicSkip) {
uicSkipList.push_back(absFile);
}
if ((targetMoc && !skipMoc) || (targetUic && !skipUic)) {
if ((mocTarget && !mocSkip) || (uicTarget && !uicSkip)) {
// Add file name to sources or headers list
switch (fileType) {
case cmSystemTools::CXX_FILE_FORMAT:
@@ -162,100 +202,87 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
}
}
static void GetCompileDefinitionsAndDirectories(
cmGeneratorTarget const* target, const std::string& config,
std::string& incs, std::string& defs)
{
std::vector<std::string> includeDirs;
cmLocalGenerator* localGen = target->GetLocalGenerator();
// Get the include dirs for this target, without stripping the implicit
// include dirs off, see https://gitlab.kitware.com/cmake/cmake/issues/13667
localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
incs = cmJoin(includeDirs, ";");
std::set<std::string> defines;
localGen->AddCompileDefinitions(defines, target, config, "CXX");
defs += cmJoin(defines, ";");
}
static void MocSetupAutoTarget(
cmGeneratorTarget const* target, const std::string& autogenTargetName,
std::vector<std::string> const& skipMoc,
const std::string& qtMajorVersion,
std::vector<std::string> const& mocSkipList,
std::map<std::string, std::string>& configIncludes,
std::map<std::string, std::string>& configDefines)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
std::string _moc_options = (tmp != CM_NULLPTR ? tmp : "");
makefile->AddDefinition(
"_moc_options", cmOutputConverter::EscapeForCMake(_moc_options).c_str());
makefile->AddDefinition(
"_skip_moc",
cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
AddDefinitionEscaped(makefile, "_moc_options",
GetSafeProperty(target, "AUTOMOC_MOC_OPTIONS"));
AddDefinitionEscaped(makefile, "_moc_skip", mocSkipList);
AddDefinitionEscaped(makefile, "_moc_relaxed_mode",
makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE") ? "TRUE"
: "FALSE");
std::string _moc_incs;
std::string _moc_compile_defs;
std::vector<std::string> configs;
const std::string& config = makefile->GetConfigurations(configs);
GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
_moc_compile_defs);
makefile->AddDefinition(
"_moc_incs", cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
makefile->AddDefinition(
"_moc_compile_defs",
cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());
for (std::vector<std::string>::const_iterator li = configs.begin();
li != configs.end(); ++li) {
std::string config_moc_incs;
std::string config_moc_compile_defs;
GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
config_moc_compile_defs);
if (config_moc_incs != _moc_incs) {
configIncludes[*li] = cmOutputConverter::EscapeForCMake(config_moc_incs);
if (_moc_incs.empty()) {
_moc_incs = config_moc_incs;
}
// Moc includes and compile definitions
{
std::string _moc_incs;
std::string _moc_compile_defs;
std::vector<std::string> configs;
{
const std::string& config = makefile->GetConfigurations(configs);
GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
_moc_compile_defs);
AddDefinitionEscaped(makefile, "_moc_incs", _moc_incs);
AddDefinitionEscaped(makefile, "_moc_compile_defs", _moc_compile_defs);
}
if (config_moc_compile_defs != _moc_compile_defs) {
configDefines[*li] =
cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
if (_moc_compile_defs.empty()) {
_moc_compile_defs = config_moc_compile_defs;
for (std::vector<std::string>::const_iterator li = configs.begin();
li != configs.end(); ++li) {
std::string config_moc_incs;
std::string config_moc_compile_defs;
GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
config_moc_compile_defs);
if (config_moc_incs != _moc_incs) {
configIncludes[*li] =
cmOutputConverter::EscapeForCMake(config_moc_incs);
if (_moc_incs.empty()) {
_moc_incs = config_moc_incs;
}
}
if (config_moc_compile_defs != _moc_compile_defs) {
configDefines[*li] =
cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
if (_moc_compile_defs.empty()) {
_moc_compile_defs = config_moc_compile_defs;
}
}
}
}
const char* qtVersion = makefile->GetDefinition("_target_qt_version");
if (strcmp(qtVersion, "5") == 0) {
cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
if (!qt5Moc) {
cmSystemTools::Error("Qt5::moc target not found ",
autogenTargetName.c_str());
return;
// Moc executable
{
std::string err;
const char* mocExec = CM_NULLPTR;
if (qtMajorVersion == "5") {
cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
if (qt5Moc != CM_NULLPTR) {
mocExec = qt5Moc->ImportedGetLocation("");
} else {
err = "Qt5::moc target not found " + autogenTargetName;
}
} else if (qtMajorVersion == "4") {
cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
if (qt4Moc != CM_NULLPTR) {
mocExec = qt4Moc->ImportedGetLocation("");
} else {
err = "Qt4::moc target not found " + autogenTargetName;
}
} else {
err = "The CMAKE_AUTOMOC feature supports only Qt 4 and Qt 5 ";
err += autogenTargetName;
}
makefile->AddDefinition("_qt_moc_executable",
qt5Moc->ImportedGetLocation(""));
} else if (strcmp(qtVersion, "4") == 0) {
cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
if (!qt4Moc) {
cmSystemTools::Error("Qt4::moc target not found ",
autogenTargetName.c_str());
return;
// Add definition or error
if (err.empty()) {
AddDefinitionEscaped(makefile, "_qt_moc_executable",
mocExec ? mocExec : "");
} else {
cmSystemTools::Error(err.c_str());
}
makefile->AddDefinition("_qt_moc_executable",
qt4Moc->ImportedGetLocation(""));
} else {
cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and "
"Qt 5 ",
autogenTargetName.c_str());
}
}
@@ -268,126 +295,126 @@ static void UicGetOpts(cmGeneratorTarget const* target,
}
static void UicSetupAutoTarget(
cmGeneratorTarget const* target, std::vector<std::string> const& skipUic,
cmGeneratorTarget const* target, const std::string& qtMajorVersion,
std::vector<std::string> const& uicSkipList,
std::map<std::string, std::string>& configUicOptions)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
std::set<std::string> skipped;
skipped.insert(skipUic.begin(), skipUic.end());
AddDefinitionEscaped(makefile, "_uic_skip", uicSkipList);
makefile->AddDefinition(
"_skip_uic",
cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());
// Uic target options
{
std::string _uic_opts;
std::vector<std::string> configs;
UicGetOpts(target, makefile->GetConfigurations(configs), _uic_opts);
std::vector<cmSourceFile*> uiFilesWithOptions =
makefile->GetQtUiFilesWithOptions();
AddDefinitionEscaped(makefile, "_uic_target_options", _uic_opts);
const char* qtVersion = makefile->GetDefinition("_target_qt_version");
std::string _uic_opts;
std::vector<std::string> configs;
const std::string& config = makefile->GetConfigurations(configs);
UicGetOpts(target, config, _uic_opts);
if (!_uic_opts.empty()) {
_uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts);
makefile->AddDefinition("_uic_target_options", _uic_opts.c_str());
}
for (std::vector<std::string>::const_iterator li = configs.begin();
li != configs.end(); ++li) {
std::string config_uic_opts;
UicGetOpts(target, *li, config_uic_opts);
if (config_uic_opts != _uic_opts) {
configUicOptions[*li] =
cmOutputConverter::EscapeForCMake(config_uic_opts);
if (_uic_opts.empty()) {
_uic_opts = config_uic_opts;
for (std::vector<std::string>::const_iterator li = configs.begin();
li != configs.end(); ++li) {
std::string config_uic_opts;
UicGetOpts(target, *li, config_uic_opts);
if (config_uic_opts != _uic_opts) {
configUicOptions[*li] =
cmOutputConverter::EscapeForCMake(config_uic_opts);
if (_uic_opts.empty()) {
_uic_opts = config_uic_opts;
}
}
}
}
// Uic files options
{
std::vector<std::string> uiFileFiles;
std::vector<std::string> uiFileOptions;
{
std::set<std::string> skipped;
skipped.insert(uicSkipList.begin(), uicSkipList.end());
std::string uiFileFiles;
std::string uiFileOptions;
const char* sep = "";
for (std::vector<cmSourceFile*>::const_iterator fileIt =
uiFilesWithOptions.begin();
fileIt != uiFilesWithOptions.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
if (!skipped.insert(absFile).second) {
continue;
const std::vector<cmSourceFile*> uiFilesWithOptions =
makefile->GetQtUiFilesWithOptions();
for (std::vector<cmSourceFile*>::const_iterator fileIt =
uiFilesWithOptions.begin();
fileIt != uiFilesWithOptions.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
const std::string absFile =
cmsys::SystemTools::GetRealPath(sf->GetFullPath());
if (skipped.insert(absFile).second) {
// The file wasn't skipped
uiFileFiles.push_back(absFile);
{
std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
uiFileOptions.push_back(opts);
}
}
}
}
uiFileFiles += sep;
uiFileFiles += absFile;
uiFileOptions += sep;
std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
uiFileOptions += opts;
sep = ";";
AddDefinitionEscaped(makefile, "_qt_uic_options_files", uiFileFiles);
AddDefinitionEscaped(makefile, "_qt_uic_options_options", uiFileOptions);
}
makefile->AddDefinition(
"_qt_uic_options_files",
cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
makefile->AddDefinition(
"_qt_uic_options_options",
cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());
std::string targetName = target->GetName();
if (strcmp(qtVersion, "5") == 0) {
cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
if (!qt5Uic) {
// Project does not use Qt5Widgets, but has AUTOUIC ON anyway
// Uic executable
{
std::string err;
const char* uicExec = CM_NULLPTR;
if (qtMajorVersion == "5") {
cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
if (qt5Uic != CM_NULLPTR) {
uicExec = qt5Uic->ImportedGetLocation("");
} else {
// Project does not use Qt5Widgets, but has AUTOUIC ON anyway
}
} else if (qtMajorVersion == "4") {
cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
if (qt4Uic != CM_NULLPTR) {
uicExec = qt4Uic->ImportedGetLocation("");
} else {
err = "Qt4::uic target not found " + target->GetName();
}
} else {
makefile->AddDefinition("_qt_uic_executable",
qt5Uic->ImportedGetLocation(""));
err = "The CMAKE_AUTOUIC feature supports only Qt 4 and Qt 5 ";
err += target->GetName();
}
} else if (strcmp(qtVersion, "4") == 0) {
cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
if (!qt4Uic) {
cmSystemTools::Error("Qt4::uic target not found ", targetName.c_str());
return;
// Add definition or error
if (err.empty()) {
AddDefinitionEscaped(makefile, "_qt_uic_executable",
uicExec ? uicExec : "");
} else {
cmSystemTools::Error(err.c_str());
}
makefile->AddDefinition("_qt_uic_executable",
qt4Uic->ImportedGetLocation(""));
} else {
cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
"Qt 5 ",
targetName.c_str());
}
}
static std::string RccGetExecutable(cmGeneratorTarget const* target,
const std::string& qtMajorVersion)
{
std::string rccExec;
cmLocalGenerator* lg = target->GetLocalGenerator();
std::string const& targetName = target->GetName();
if (qtMajorVersion == "5") {
cmGeneratorTarget* qt5Rcc = lg->FindGeneratorTargetToUse("Qt5::rcc");
if (!qt5Rcc) {
cmSystemTools::Error("Qt5::rcc target not found ", targetName.c_str());
return std::string();
if (qt5Rcc != CM_NULLPTR) {
rccExec = qt5Rcc->ImportedGetLocation("");
} else {
cmSystemTools::Error("Qt5::rcc target not found ",
target->GetName().c_str());
}
return qt5Rcc->ImportedGetLocation("");
}
if (qtMajorVersion == "4") {
} else if (qtMajorVersion == "4") {
cmGeneratorTarget* qt4Rcc = lg->FindGeneratorTargetToUse("Qt4::rcc");
if (!qt4Rcc) {
cmSystemTools::Error("Qt4::rcc target not found ", targetName.c_str());
return std::string();
if (qt4Rcc != CM_NULLPTR) {
rccExec = qt4Rcc->ImportedGetLocation("");
} else {
cmSystemTools::Error("Qt4::rcc target not found ",
target->GetName().c_str());
}
return qt4Rcc->ImportedGetLocation("");
} else {
cmSystemTools::Error(
"The CMAKE_AUTORCC feature supports only Qt 4 and Qt 5 ",
target->GetName().c_str());
}
cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and "
"Qt 5 ",
targetName.c_str());
return std::string();
return rccExec;
}
static void RccMergeOptions(std::vector<std::string>& opts,
@@ -397,26 +424,31 @@ static void RccMergeOptions(std::vector<std::string>& opts,
static const char* valueOptions[] = { "name", "root", "compress",
"threshold" };
std::vector<std::string> extraOpts;
for (std::vector<std::string>::const_iterator it = fileOpts.begin();
it != fileOpts.end(); ++it) {
for (std::vector<std::string>::const_iterator fit = fileOpts.begin();
fit != fileOpts.end(); ++fit) {
std::vector<std::string>::iterator existingIt =
std::find(opts.begin(), opts.end(), *it);
std::find(opts.begin(), opts.end(), *fit);
if (existingIt != opts.end()) {
const char* o = it->c_str();
if (*o == '-') {
++o;
const char* optName = fit->c_str();
if (*optName == '-') {
++optName;
if (isQt5 && *optName == '-') {
++optName;
}
}
if (isQt5 && *o == '-') {
++o;
}
if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
cmStrCmp(*it)) != cmArrayEnd(valueOptions)) {
assert(existingIt + 1 != opts.end());
*(existingIt + 1) = *(it + 1);
++it;
// Test if this is a value option and change the existing value
if ((optName != fit->c_str()) &&
std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
cmStrCmp(optName)) != cmArrayEnd(valueOptions)) {
const std::vector<std::string>::iterator existValueIt(existingIt + 1);
const std::vector<std::string>::const_iterator fileValueIt(fit + 1);
if ((existValueIt != opts.end()) && (fileValueIt != fileOpts.end())) {
*existValueIt = *fileValueIt;
++fit;
}
}
} else {
extraOpts.push_back(*it);
extraOpts.push_back(*fit);
}
}
opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
@@ -526,23 +558,20 @@ static bool RccListInputsQt4(cmSourceFile* sf,
}
cmsys::RegularExpression fileMatchRegex("(<file[^<]+)");
cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
size_t offset = 0;
while (fileMatchRegex.find(qrcContents.c_str() + offset)) {
std::string qrcEntry = fileMatchRegex.match(1);
offset += qrcEntry.size();
cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
fileReplaceRegex.find(qrcEntry);
std::string tag = fileReplaceRegex.match(1);
qrcEntry = qrcEntry.substr(tag.size());
{
fileReplaceRegex.find(qrcEntry);
std::string tag = fileReplaceRegex.match(1);
qrcEntry = qrcEntry.substr(tag.size());
}
if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str())) {
qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry;
}
depends.push_back(qrcEntry);
}
return true;
@@ -563,89 +592,69 @@ static bool RccListInputs(const std::string& qtMajorVersion, cmSourceFile* sf,
static void RccSetupAutoTarget(cmGeneratorTarget const* target,
const std::string& qtMajorVersion)
{
std::string _rcc_files;
const char* sepRccFiles = "";
cmMakefile* makefile = target->Target->GetMakefile();
const bool qtMajorVersion5 = (qtMajorVersion == "5");
std::vector<std::string> _rcc_files;
std::vector<std::string> _rcc_inputs;
std::vector<std::string> rccFileFiles;
std::vector<std::string> rccFileOptions;
std::vector<std::string> rccOptionsTarget;
if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) {
cmSystemTools::ExpandListArgument(opts, rccOptionsTarget);
}
std::vector<cmSourceFile*> srcFiles;
target->GetConfigCommonSourceFiles(srcFiles);
std::string qrcInputs;
const char* qrcInputsSep = "";
std::string rccFileFiles;
std::string rccFileOptions;
const char* optionSep = "";
const bool qtMajorVersion5 = (qtMajorVersion == "5");
std::vector<std::string> rccOptions;
if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) {
cmSystemTools::ExpandListArgument(opts, rccOptions);
}
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
fileIt != srcFiles.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
std::string ext = sf->GetExtension();
if (ext == "qrc") {
std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
if (sf->GetExtension() == "qrc") {
const bool skip =
cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOGEN")) ||
cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"));
if (!skip) {
_rcc_files += sepRccFiles;
_rcc_files += absFile;
sepRccFiles = ";";
if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
std::vector<std::string> optsVec;
cmSystemTools::ExpandListArgument(prop, optsVec);
RccMergeOptions(rccOptions, optsVec, qtMajorVersion5);
const std::string absFile =
cmsys::SystemTools::GetRealPath(sf->GetFullPath());
// qrc file
_rcc_files.push_back(absFile);
// qrc file entries
{
std::string entriesList;
if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
std::vector<std::string> depends;
if (RccListInputs(qtMajorVersion, sf, target, depends)) {
entriesList = cmJoin(depends, "@list_sep@");
} else {
return;
}
}
_rcc_inputs.push_back(entriesList);
}
if (!rccOptions.empty()) {
rccFileFiles += optionSep;
rccFileFiles += absFile;
rccFileOptions += optionSep;
}
const char* listSep = "";
for (std::vector<std::string>::const_iterator it = rccOptions.begin();
it != rccOptions.end(); ++it) {
rccFileOptions += listSep;
rccFileOptions += *it;
listSep = "@list_sep@";
}
optionSep = ";";
std::string entriesList;
if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
std::vector<std::string> depends;
if (RccListInputs(qtMajorVersion, sf, target, depends)) {
entriesList = cmJoin(depends, "@list_sep@");
} else {
return;
// rcc options for this qrc file
{
// Merged target and file options
std::vector<std::string> rccOptions(rccOptionsTarget);
if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
std::vector<std::string> optsVec;
cmSystemTools::ExpandListArgument(prop, optsVec);
RccMergeOptions(rccOptions, optsVec, qtMajorVersion5);
}
// Only store non empty options lists
if (!rccOptions.empty()) {
rccFileFiles.push_back(absFile);
rccFileOptions.push_back(cmJoin(rccOptions, "@list_sep@"));
}
}
qrcInputs += qrcInputsSep;
qrcInputs += entriesList;
qrcInputsSep = ";";
}
}
}
makefile->AddDefinition(
"_rcc_inputs", cmOutputConverter::EscapeForCMake(qrcInputs).c_str());
makefile->AddDefinition(
"_rcc_files", cmOutputConverter::EscapeForCMake(_rcc_files).c_str());
makefile->AddDefinition(
"_rcc_options_files",
cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
makefile->AddDefinition(
"_rcc_options_options",
cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());
makefile->AddDefinition("_qt_rcc_executable",
RccGetExecutable(target, qtMajorVersion).c_str());
AddDefinitionEscaped(makefile, "_rcc_files", _rcc_files);
AddDefinitionEscaped(makefile, "_rcc_inputs", _rcc_inputs);
AddDefinitionEscaped(makefile, "_rcc_options_files", rccFileFiles);
AddDefinitionEscaped(makefile, "_rcc_options_options", rccFileOptions);
AddDefinitionEscaped(makefile, "_qt_rcc_executable",
RccGetExecutable(target, qtMajorVersion));
}
void cmQtAutoGeneratorInitializer::InitializeAutogenSources(
@@ -872,47 +881,42 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
cmMakefile::ScopePushPop varScope(makefile);
static_cast<void>(varScope);
// create a custom target for running generators at buildtime:
const std::string autogenTargetName = GetAutogenTargetName(target);
const std::string qtMajorVersion = GetQtMajorVersion(target);
makefile->AddDefinition(
"_moc_target_name",
cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
makefile->AddDefinition(
"_origin_target_name",
cmOutputConverter::EscapeForCMake(target->GetName()).c_str());
makefile->AddDefinition("_target_qt_version", qtMajorVersion.c_str());
std::vector<std::string> mocUicSources;
std::vector<std::string> mocUicHeaders;
std::vector<std::string> skipMoc;
std::vector<std::string> skipUic;
std::map<std::string, std::string> configMocIncludes;
std::map<std::string, std::string> configMocDefines;
std::map<std::string, std::string> configUicOptions;
{
// create a custom target for running generators at buildtime:
const std::string autogenTargetName = GetAutogenTargetName(target);
const std::string qtMajorVersion = GetQtMajorVersion(target);
if (target->GetPropertyAsBool("AUTOMOC") ||
target->GetPropertyAsBool("AUTOUIC") ||
target->GetPropertyAsBool("AUTORCC")) {
SetupSourceFiles(target, mocUicSources, mocUicHeaders, skipMoc, skipUic);
}
makefile->AddDefinition(
"_moc_uic_sources",
cmOutputConverter::EscapeForCMake(cmJoin(mocUicSources, ";")).c_str());
makefile->AddDefinition(
"_moc_uic_headers",
cmOutputConverter::EscapeForCMake(cmJoin(mocUicHeaders, ";")).c_str());
AddDefinitionEscaped(makefile, "_autogen_target_name", autogenTargetName);
AddDefinitionEscaped(makefile, "_origin_target_name", target->GetName());
AddDefinitionEscaped(makefile, "_qt_version_major", qtMajorVersion);
if (target->GetPropertyAsBool("AUTOMOC")) {
MocSetupAutoTarget(target, autogenTargetName, skipMoc, configMocIncludes,
configMocDefines);
}
if (target->GetPropertyAsBool("AUTOUIC")) {
UicSetupAutoTarget(target, skipUic, configUicOptions);
}
if (target->GetPropertyAsBool("AUTORCC")) {
RccSetupAutoTarget(target, qtMajorVersion);
std::vector<std::string> _sources;
std::vector<std::string> _headers;
std::vector<std::string> mocSkipList;
std::vector<std::string> uicSkipList;
if (target->GetPropertyAsBool("AUTOMOC") ||
target->GetPropertyAsBool("AUTOUIC") ||
target->GetPropertyAsBool("AUTORCC")) {
SetupSourceFiles(target, _sources, _headers, mocSkipList, uicSkipList);
}
AddDefinitionEscaped(makefile, "_sources", _sources);
AddDefinitionEscaped(makefile, "_headers", _headers);
if (target->GetPropertyAsBool("AUTOMOC")) {
MocSetupAutoTarget(target, autogenTargetName, qtMajorVersion,
mocSkipList, configMocIncludes, configMocDefines);
}
if (target->GetPropertyAsBool("AUTOUIC")) {
UicSetupAutoTarget(target, qtMajorVersion, uicSkipList,
configUicOptions);
}
if (target->GetPropertyAsBool("AUTORCC")) {
RccSetupAutoTarget(target, qtMajorVersion);
}
}
// Generate config file
@@ -924,7 +928,7 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(), false, true,
false);
// Append custom definitions to config file
// Append custom config definitions to info file
if (!configMocDefines.empty() || !configMocIncludes.empty() ||
!configUicOptions.empty()) {
@@ -946,33 +950,34 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
error += outputFile;
error += " for writing.";
cmSystemTools::Error(error.c_str());
return;
}
if (!configMocDefines.empty()) {
for (std::map<std::string, std::string>::iterator
it = configMocDefines.begin(),
end = configMocDefines.end();
it != end; ++it) {
infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
<< it->second << ")\n";
} else {
infoFile << "# Configuration specific options\n";
if (!configMocDefines.empty()) {
for (std::map<std::string, std::string>::iterator
it = configMocDefines.begin(),
end = configMocDefines.end();
it != end; ++it) {
infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
<< it->second << ")\n";
}
}
}
if (!configMocIncludes.empty()) {
for (std::map<std::string, std::string>::iterator
it = configMocIncludes.begin(),
end = configMocIncludes.end();
it != end; ++it) {
infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
<< ")\n";
if (!configMocIncludes.empty()) {
for (std::map<std::string, std::string>::iterator
it = configMocIncludes.begin(),
end = configMocIncludes.end();
it != end; ++it) {
infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
<< ")\n";
}
}
}
if (!configUicOptions.empty()) {
for (std::map<std::string, std::string>::iterator
it = configUicOptions.begin(),
end = configUicOptions.end();
it != end; ++it) {
infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
<< it->second << ")\n";
if (!configUicOptions.empty()) {
for (std::map<std::string, std::string>::iterator
it = configUicOptions.begin(),
end = configUicOptions.end();
it != end; ++it) {
infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
<< it->second << ")\n";
}
}
}
}

1602
Source/cmQtAutoGenerators.cxx
View File

File diff suppressed because it is too large Load Diff

170
Source/cmQtAutoGenerators.h
View File

@@ -7,10 +7,10 @@
#include <cmFilePathChecksum.h>
#include <cmsys/RegularExpression.hxx>
#include <list>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
class cmMakefile;
@@ -22,64 +22,92 @@ public:
bool Run(const std::string& targetDirectory, const std::string& config);
private:
// - Types
/// @brief Used to extract additional dependencies from content text
struct MocDependFilter
{
std::string key;
cmsys::RegularExpression regExp;
};
typedef std::pair<std::string, cmsys::RegularExpression> MacroFilter;
// - Configuration
bool ReadAutogenInfoFile(cmMakefile* makefile,
const std::string& targetDirectory,
const std::string& config);
std::string MocSettingsStringCompose();
std::string UicSettingsStringCompose();
std::string RccSettingsStringCompose();
void OldSettingsReadFile(cmMakefile* makefile,
const std::string& targetDirectory);
bool OldSettingsWriteFile(const std::string& targetDirectory);
bool MocEnabled() const { return !this->MocExecutable.empty(); }
bool UicEnabled() const { return !this->UicExecutable.empty(); }
bool RccEnabled() const { return !this->RccExecutable.empty(); }
// - Settings file
void SettingsFileRead(cmMakefile* makefile,
const std::string& targetDirectory);
bool SettingsFileWrite(const std::string& targetDirectory);
bool GenerateAllAny() const
{
return (this->GenerateAllMoc || this->GenerateAllRcc ||
this->GenerateAllUic);
}
// - Init and run
void Init();
bool RunAutogen(cmMakefile* makefile);
void Init(cmMakefile* makefile);
bool RunAutogen();
// - Content analysis
bool MocRequired(const std::string& text, std::string& macroName);
bool MocSkipTest(const std::string& absFilename);
bool UicSkipTest(const std::string& absFilename);
bool MocRequired(const std::string& contentText,
std::string* macroName = CM_NULLPTR);
void MocFindDepends(
const std::string& absFilename, const std::string& contentText,
std::map<std::string, std::set<std::string> >& mocDepends);
bool MocSkip(const std::string& absFilename) const;
bool UicSkip(const std::string& absFilename) const;
bool ParseSourceFile(
const std::string& absFilename,
const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& includedMocs,
std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::set<std::string> >& mocDepends,
std::map<std::string, std::vector<std::string> >& includedUis,
bool relaxed);
void SearchHeadersForSourceFile(
const std::string& absFilename,
const std::vector<std::string>& headerExtensions,
std::set<std::string>& absHeadersMoc,
std::set<std::string>& absHeadersUic);
void SearchHeadersForSourceFile(const std::string& absFilename,
std::set<std::string>& mocHeaderFiles,
std::set<std::string>& uicHeaderFiles) const;
void ParseHeaders(
const std::set<std::string>& absHeadersMoc,
const std::set<std::string>& absHeadersUic,
const std::map<std::string, std::string>& includedMocs,
std::map<std::string, std::string>& notIncludedMocs,
const std::set<std::string>& mocHeaderFiles,
const std::set<std::string>& uicHeaderFiles,
const std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::string>& mocsNotIncluded,
std::map<std::string, std::set<std::string> >& mocDepends,
std::map<std::string, std::vector<std::string> >& includedUis);
void ParseContentForUic(
const std::string& fileName, const std::string& contentsString,
void UicParseContent(
const std::string& fileName, const std::string& contentText,
std::map<std::string, std::vector<std::string> >& includedUis);
bool ParseContentForMoc(const std::string& absFilename,
const std::string& contentsString,
const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& includedMocs,
bool relaxed);
bool MocParseSourceContent(
const std::string& absFilename, const std::string& contentText,
std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed);
void MocParseHeaderContent(
const std::string& absFilename, const std::string& contentText,
std::map<std::string, std::string>& mocsNotIncluded,
std::map<std::string, std::set<std::string> >& mocDepends);
// - Moc file generation
bool MocGenerateAll(
const std::map<std::string, std::string>& includedMocs,
const std::map<std::string, std::string>& notIncludedMocs);
bool MocGenerateFile(const std::string& sourceFile,
const std::string& mocFileName,
const std::string& subDirPrefix);
const std::map<std::string, std::string>& mocsIncluded,
const std::map<std::string, std::string>& mocsNotIncluded,
const std::map<std::string, std::set<std::string> >& mocDepends);
bool MocGenerateFile(
const std::string& sourceFile, const std::string& mocFileName,
const std::string& subDirPrefix,
const std::map<std::string, std::set<std::string> >& mocDepends);
// - Uic file generation
bool UicGenerateAll(
@@ -88,25 +116,39 @@ private:
const std::string& uiInputFile,
const std::string& uiOutputFile);
// - Qrc file generation
bool QrcGenerateAll();
bool QrcGenerateFile(const std::string& qrcInputFile,
// - Rcc file generation
bool RccGenerateAll();
bool RccGenerateFile(const std::string& qrcInputFile,
const std::string& qrcOutputFile, bool unique_n);
// - Logging
void LogErrorNameCollision(
const std::string& message,
const std::multimap<std::string, std::string>& collisions);
void LogBold(const std::string& message);
void LogInfo(const std::string& message);
void LogWarning(const std::string& message);
void LogError(const std::string& message);
void LogCommand(const std::vector<std::string>& command);
const std::multimap<std::string, std::string>& collisions) const;
void LogBold(const std::string& message) const;
void LogInfo(const std::string& message) const;
void LogWarning(const std::string& message) const;
void LogError(const std::string& message) const;
void LogCommand(const std::vector<std::string>& command) const;
// - Utility
bool NameCollisionTest(const std::map<std::string, std::string>& genFiles,
std::multimap<std::string, std::string>& collisions);
bool MakeParentDirectory(const std::string& filename);
bool NameCollisionTest(
const std::map<std::string, std::string>& genFiles,
std::multimap<std::string, std::string>& collisions) const;
std::string ChecksumedPath(const std::string& sourceFile,
const char* basePrefix,
const char* baseSuffix) const;
bool MakeParentDirectory(const std::string& filename) const;
bool FindHeader(std::string& header, const std::string& testBasePath) const;
bool FindHeaderGlobal(std::string& header,
const std::string& testBasePath) const;
std::string FindMocHeader(const std::string& basePath,
const std::string& baseName,
const std::string& subDir) const;
std::string FindIncludedFile(const std::string& sourceFile,
const std::string& includeString) const;
std::string FindInIncludeDirectories(const std::string& includeString) const;
// - Target names
std::string OriginTargetName;
@@ -125,31 +167,31 @@ private:
// - File lists
std::vector<std::string> Sources;
std::vector<std::string> Headers;
// - Settings
std::string SettingsStringMoc;
std::string SettingsStringUic;
std::string SettingsStringRcc;
// - Moc
std::vector<std::string> SkipMoc;
std::string MocCompileDefinitionsStr;
std::string MocIncludesStr;
std::string MocOptionsStr;
std::string OutMocCppFilenameRel;
std::string OutMocCppFilenameAbs;
std::list<std::string> MocIncludes;
std::list<std::string> MocDefinitions;
std::string MocCppFilenameRel;
std::string MocCppFilenameAbs;
std::vector<std::string> MocSkipList;
std::vector<std::string> MocIncludePaths;
std::vector<std::string> MocIncludes;
std::vector<std::string> MocDefinitions;
std::vector<std::string> MocOptions;
std::string MocSettingsString;
std::vector<MocDependFilter> MocDependFilters;
// - Uic
std::vector<std::string> SkipUic;
std::vector<std::string> UicSkipList;
std::vector<std::string> UicTargetOptions;
std::map<std::string, std::string> UicOptions;
std::string UicSettingsString;
// - Rcc
std::vector<std::string> RccSources;
std::map<std::string, std::string> RccOptions;
std::map<std::string, std::vector<std::string> > RccInputs;
std::string RccSettingsString;
// - Utility
cmFilePathChecksum fpathCheckSum;
cmsys::RegularExpression RegExpQObject;
cmsys::RegularExpression RegExpQGadget;
std::vector<std::string> HeaderExtensions;
MacroFilter MacroFilters[2];
cmsys::RegularExpression RegExpMocInclude;
cmsys::RegularExpression RegExpUicInclude;
// - Flags
@@ -159,9 +201,9 @@ private:
bool RunMocFailed;
bool RunUicFailed;
bool RunRccFailed;
bool GenerateMocAll;
bool GenerateUicAll;
bool GenerateRccAll;
bool GenerateAllMoc;
bool GenerateAllUic;
bool GenerateAllRcc;
bool MocRelaxedMode;
};

91
Tests/QtAutogen/CMakeLists.txt
View File

@@ -46,26 +46,26 @@ endif()
get_property(QT_COMPILE_FEATURES TARGET ${QT_QTCORE_TARGET} PROPERTY INTERFACE_COMPILE_FEATURES)
# -- Test: AUTORCC
# -- Test
# RCC only
add_executable(rccOnly rccOnly.cpp rccOnlyRes.qrc)
set_property(TARGET rccOnly PROPERTY AUTORCC ON)
target_link_libraries(rccOnly ${QT_QTCORE_TARGET})
# -- Test: AUTORCC
# -- Test
# RCC empty
add_executable(rccEmpty rccEmpty.cpp rccEmptyRes.qrc)
set_property(TARGET rccEmpty PROPERTY AUTORCC ON)
target_link_libraries(rccEmpty ${QT_QTCORE_TARGET})
# -- Test: AUTOUIC
# -- Test
# UIC only
qtx_wrap_cpp(uicOnlyMoc uicOnlySource/uiconly.h)
add_executable(uicOnly uicOnlySource/uiconly.cpp ${uicOnlyMoc})
set_property(TARGET uicOnly PROPERTY AUTOUIC ON)
target_link_libraries(uicOnly ${QT_LIBRARIES})
# -- Test: AUTOMOC, AUTORCC
# -- Test
# Add not_generated_file.qrc to the source list to get the file-level
# dependency, but don't generate a c++ file from it. Disable the AUTORCC
# feature for this target. This tests that qrc files in the sources don't
@@ -80,13 +80,14 @@ set_target_properties(no_link_language PROPERTIES AUTOMOC TRUE)
target_compile_features(no_link_language PRIVATE ${QT_COMPILE_FEATURES})
target_compile_features(empty PRIVATE ${QT_COMPILE_FEATURES})
# -- Test: AUTORCC
# -- Test
# When a file listed in a .qrc file changes the target must be rebuilt
try_compile(RCC_DEPENDS
"${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends"
"${CMAKE_CURRENT_SOURCE_DIR}/autorcc_depends"
autorcc_depends
CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
"-DQT_TEST_VERSION=${QT_TEST_VERSION}"
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
OUTPUT_VARIABLE output
)
@@ -115,13 +116,14 @@ if (NOT file1_step1 GREATER file1_before)
message(SEND_ERROR "file1 (${qrc_file1}) should have changed in the first step!")
endif()
# -- Test: AUTOMOC
# -- Test
# Ensure a repeated build succeeds when a header containing a QObject changes
try_compile(MOC_RERUN
"${CMAKE_CURRENT_BINARY_DIR}/automoc_rerun"
"${CMAKE_CURRENT_SOURCE_DIR}/automoc_rerun"
automoc_rerun
CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
"-DQT_TEST_VERSION=${QT_TEST_VERSION}"
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
OUTPUT_VARIABLE output
)
@@ -139,7 +141,7 @@ if (automoc_rerun_result)
message(SEND_ERROR "Second build of automoc_rerun failed.")
endif()
# -- Test: AUTOMOC, SKIP_AUTOMOC
# -- Test
# Test for SKIP_AUTOMOC and SKIP_AUTOGEN on an AUTOMOC enabled target
qtx_wrap_cpp(skipMocWrapMoc
skipSource/qItemA.hpp
@@ -161,7 +163,7 @@ set_property(TARGET skipMocB PROPERTY AUTOMOC ON)
set_property(TARGET skipMocB PROPERTY AUTOUIC ON)
target_link_libraries(skipMocB ${QT_LIBRARIES})
# -- Test: AUTOUIC, SKIP_AUTOUIC
# -- Test
# Test for SKIP_AUTOUIC and SKIP_AUTOGEN on an AUTOUIC enabled target
set(skipUicSources
skipUic.cpp
@@ -181,7 +183,7 @@ set_property(TARGET skipUicB PROPERTY AUTOUIC ON)
set_property(TARGET skipUicB PROPERTY AUTOMOC ON)
target_link_libraries(skipUicB ${QT_LIBRARIES})
# -- Test: AUTORCC, SKIP_AUTORCC
# -- Test
# Test for SKIP_AUTORCC and SKIP_AUTOGEN on an AUTORCC enabled target
set(skipRccSources
skipRcc.cpp
@@ -202,10 +204,73 @@ set_property(TARGET skipRccB PROPERTY AUTOUIC ON)
set_property(TARGET skipRccB PROPERTY AUTOMOC ON)
target_link_libraries(skipRccB ${QT_LIBRARIES})
# -- Test: AUTOMOC AUTORCC
# -- Test
# Source files with the same basename in different subdirectories
add_subdirectory(sameName)
# -- Test: AUTOMOC AUTORCC AUTOUIC
# -- Test
# Tests various include moc patterns
add_subdirectory(mocIncludeStrict)
# -- Test
# Tests various include moc patterns
add_subdirectory(mocIncludeRelaxed)
# -- Test
# Tests Q_PLUGIN_METADATA json file change detection
if (NOT QT_TEST_VERSION STREQUAL 4)
try_compile(MOC_PLUGIN
"${CMAKE_CURRENT_BINARY_DIR}/mocPlugin"
"${CMAKE_CURRENT_SOURCE_DIR}/mocPlugin"
mocPlugin
CMAKE_FLAGS "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
OUTPUT_VARIABLE output
)
if (NOT MOC_PLUGIN)
message(SEND_ERROR "Initial build of mocPlugin failed. Output: ${output}")
endif()
set(timeformat "%Y%j%H%M%S")
set(mocPluginBinDir "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin")
find_library(style_a_file "PluginStyleA" "${mocPluginBinDir}")
find_library(style_b_file "PluginStyleB" "${mocPluginBinDir}")
find_library(style_c_file "PluginStyleC" "${mocPluginBinDir}")
find_library(style_d_file "PluginStyleD" "${mocPluginBinDir}")
file(TIMESTAMP "${style_a_file}" style_a_before "${timeformat}")
file(TIMESTAMP "${style_b_file}" style_b_before "${timeformat}")
file(TIMESTAMP "${style_c_file}" style_c_before "${timeformat}")
file(TIMESTAMP "${style_d_file}" style_d_before "${timeformat}")
# Ensure that the timestamp will change and touch the json files
execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep 1)
execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${mocPluginBinDir}/jsonFiles/StyleC.json")
execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${mocPluginBinDir}/jsonFiles/sub/StyleD.json")
execute_process(COMMAND "${CMAKE_COMMAND}" --build .
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin"
)
file(TIMESTAMP "${style_a_file}" style_a_after "${timeformat}")
file(TIMESTAMP "${style_b_file}" style_b_after "${timeformat}")
file(TIMESTAMP "${style_c_file}" style_c_after "${timeformat}")
file(TIMESTAMP "${style_d_file}" style_d_after "${timeformat}")
if (style_a_after GREATER style_a_before)
message(SEND_ERROR "file (${style_a_file}) should not have changed!")
endif()
if (style_b_after GREATER style_b_before)
message(SEND_ERROR "file (${style_b_file}) should not have changed!")
endif()
if (NOT style_c_after GREATER style_c_before)
message(SEND_ERROR "file (${style_c_file}) should have changed!")
endif()
if (NOT style_d_after GREATER style_d_before)
message(SEND_ERROR "file (${style_d_file}) should have changed!")
endif()
endif()
# -- Test
# Complex test case
add_subdirectory(complex)

24
Tests/QtAutogen/mocInclude/ObjA.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include "ObjA.hpp"
class SubObjA : public QObject
{
Q_OBJECT
public:
SubObjA() {}
~SubObjA() {}
Q_SLOT
void aSlot();
};
void SubObjA::aSlot()
{
}
void ObjA::go()
{
SubObjA subObj;
}
#include "ObjA.moc"

13
Tests/QtAutogen/mocInclude/ObjA.hpp Normal file
View File

@@ -0,0 +1,13 @@
#ifndef OBJA_HPP
#define OBJA_HPP
#include <QObject>
class ObjA : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
#endif

25
Tests/QtAutogen/mocInclude/ObjB.cpp Normal file
View File

@@ -0,0 +1,25 @@
#include "ObjB.hpp"
class SubObjB : public QObject
{
Q_OBJECT
public:
SubObjB() {}
~SubObjB() {}
Q_SLOT
void aSlot();
};
void SubObjB::aSlot()
{
}
void ObjB::go()
{
SubObjB subObj;
}
#include "ObjB.moc"
#include "moc_ObjB.cpp"

13
Tests/QtAutogen/mocInclude/ObjB.hpp Normal file
View File

@@ -0,0 +1,13 @@
#ifndef OBJB_HPP
#define OBJB_HPP
#include <QObject>
class ObjB : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
#endif

26
Tests/QtAutogen/mocInclude/ObjC.cpp Normal file
View File

@@ -0,0 +1,26 @@
#include "ObjC.hpp"
class SubObjC : public QObject
{
Q_OBJECT
public:
SubObjC() {}
~SubObjC() {}
Q_SLOT
void aSlot();
};
void SubObjC::aSlot()
{
}
void ObjC::go()
{
SubObjC subObj;
}
#include "ObjC.moc"
// Not the own header
#include "moc_ObjD.cpp"

13
Tests/QtAutogen/mocInclude/ObjC.hpp Normal file
View File

@@ -0,0 +1,13 @@
#ifndef OBJC_HPP
#define OBJC_HPP
#include <QObject>
class ObjC : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
#endif

26
Tests/QtAutogen/mocInclude/ObjD.cpp Normal file
View File

@@ -0,0 +1,26 @@
#include "ObjD.hpp"
class SubObjD : public QObject
{
Q_OBJECT
public:
SubObjD() {}
~SubObjD() {}
Q_SLOT
void aSlot();
};
void SubObjD::aSlot()
{
}
void ObjD::go()
{
SubObjD subObj;
}
#include "ObjD.moc"
// Header in subdirectory
#include "subA/moc_SubObjA.cpp"

13
Tests/QtAutogen/mocInclude/ObjD.hpp Normal file
View File

@@ -0,0 +1,13 @@
#ifndef OBJD_HPP
#define OBJD_HPP
#include <QObject>
class ObjD : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
#endif

27
Tests/QtAutogen/mocInclude/subA/SubObjA.cpp Normal file
View File

@@ -0,0 +1,27 @@
#include "SubObjA.hpp"
namespace subA {
class SubObjA : public QObject
{
Q_OBJECT
public:
SubObjA() {}
~SubObjA() {}
Q_SLOT
void aSlot();
};
void SubObjA::aSlot()
{
}
void ObjA::go()
{
SubObjA subObj;
}
}
#include "SubObjA.moc"

16
Tests/QtAutogen/mocInclude/subA/SubObjA.hpp Normal file
View File

@@ -0,0 +1,16 @@
#ifndef SUBOBJA_HPP
#define SUBOBJA_HPP
#include <QObject>
namespace subA {
class ObjA : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
}
#endif

27
Tests/QtAutogen/mocInclude/subB/SubObjB.cpp Normal file
View File

@@ -0,0 +1,27 @@
#include "SubObjB.hpp"
namespace subB {
class SubObjB : public QObject
{
Q_OBJECT
public:
SubObjB() {}
~SubObjB() {}
Q_SLOT
void aSlot();
};
void SubObjB::aSlot()
{
}
void ObjB::go()
{
SubObjB subObj;
}
}
#include "SubObjB.moc"

16
Tests/QtAutogen/mocInclude/subB/SubObjB.hpp Normal file
View File

@@ -0,0 +1,16 @@
#ifndef SUBOBJB_HPP
#define SUBOBJB_HPP
#include <QObject>
namespace subB {
class ObjB : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
}
#endif

27
Tests/QtAutogen/mocInclude/subC/SubObjC.cpp Normal file
View File

@@ -0,0 +1,27 @@
#include "SubObjC.hpp"
namespace subC {
class SubObjC : public QObject
{
Q_OBJECT
public:
SubObjC() {}
~SubObjC() {}
Q_SLOT
void aSlot();
};
void SubObjC::aSlot()
{
}
void ObjC::go()
{
SubObjC subObj;
}
}
#include "SubObjC.moc"

16
Tests/QtAutogen/mocInclude/subC/SubObjC.hpp Normal file
View File

@@ -0,0 +1,16 @@
#ifndef SUBOBJC_HPP
#define SUBOBJC_HPP
#include <QObject>
namespace subC {
class ObjC : public QObject
{
Q_OBJECT
Q_SLOT
void go();
};
}
#endif

18
Tests/QtAutogen/mocIncludeRelaxed/CMakeLists.txt Normal file
View File

@@ -0,0 +1,18 @@
# Test moc include patterns
set(CMAKE_AUTOMOC_RELAXED_MODE TRUE)
include_directories("../mocInclude")
add_executable(mocIncludeRelaxed
../mocInclude/ObjA.cpp
../mocInclude/ObjB.cpp
../mocInclude/ObjC.cpp
../mocInclude/ObjD.cpp
../mocInclude/subA/SubObjA.cpp
../mocInclude/subB/SubObjB.cpp
../mocInclude/subC/SubObjC.cpp
main.cpp
)
target_link_libraries(mocIncludeRelaxed ${QT_LIBRARIES})
set_target_properties(mocIncludeRelaxed PROPERTIES AUTOMOC ON)

14
Tests/QtAutogen/mocIncludeRelaxed/main.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include "ObjA.hpp"
#include "ObjB.hpp"
#include "ObjC.hpp"
int main(int argv, char** args)
{
ObjA objA;
ObjB objB;
ObjC objC;
return 0;
}
// Header in global subdirectory
#include "subB/moc_SubObjB.cpp"

18
Tests/QtAutogen/mocIncludeStrict/CMakeLists.txt Normal file
View File

@@ -0,0 +1,18 @@
# Test moc include patterns
set(CMAKE_AUTOMOC_RELAXED_MODE FALSE)
include_directories("../mocInclude")
add_executable(mocIncludeStrict
../mocInclude/ObjA.cpp
../mocInclude/ObjB.cpp
../mocInclude/ObjC.cpp
../mocInclude/ObjD.cpp
../mocInclude/subA/SubObjA.cpp
../mocInclude/subB/SubObjB.cpp
../mocInclude/subC/SubObjC.cpp
main.cpp
)
target_link_libraries(mocIncludeStrict ${QT_LIBRARIES})
set_target_properties(mocIncludeStrict PROPERTIES AUTOMOC ON)

14
Tests/QtAutogen/mocIncludeStrict/main.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include "ObjA.hpp"
#include "ObjB.hpp"
#include "ObjC.hpp"
int main(int argv, char** args)
{
ObjA objA;
ObjB objB;
ObjC objC;
return 0;
}
// Header in global subdirectory
#include "subB/moc_SubObjB.cpp"

25
Tests/QtAutogen/mocPlugin/CMakeLists.txt Normal file
View File

@@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.8)
if (NOT QT_TEST_VERSION STREQUAL 5)
message(SEND_ERROR "Invalid Qt version specified.")
endif()
find_package(Qt5Widgets REQUIRED)
if(Qt5_POSITION_INDEPENDENT_CODE AND CMAKE_CXX_COMPILE_OPTIONS_PIC)
add_definitions(${CMAKE_CXX_COMPILE_OPTIONS_PIC})
endif()
configure_file(jsonIn/StyleC.json jsonFiles/StyleC.json @ONLY)
configure_file(jsonIn/StyleD.json jsonFiles/sub/StyleD.json @ONLY)
# Enable automoc
set(CMAKE_AUTOMOC TRUE)
include_directories("${CMAKE_CURRENT_BINARY_DIR}/jsonFiles")
link_libraries(Qt5::Widgets)
add_library(PluginStyleA MODULE StyleA.cpp)
add_library(PluginStyleB MODULE StyleB.cpp)
add_library(PluginStyleC MODULE StyleC.cpp)
add_library(PluginStyleD MODULE StyleD.cpp)
add_library(PluginStyleE MODULE StyleE.cpp)

6
Tests/QtAutogen/mocPlugin/StyleA.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "StyleA.hpp"
QStyle* StyleA::create(const QString& key)
{
return 0;
}

15
Tests/QtAutogen/mocPlugin/StyleA.hpp Normal file
View File

@@ -0,0 +1,15 @@
#ifndef STYLEA_HPP
#define STYLEA_HPP
#include <QStylePlugin>
class StyleA : public QStylePlugin
{
Q_OBJECT
// Json file in local directory
Q_PLUGIN_METADATA(IID "org.styles.A" FILE "StyleA.json")
public:
QStyle* create(const QString& key);
};
#endif

1
Tests/QtAutogen/mocPlugin/StyleA.json Normal file
View File

@@ -0,0 +1 @@
{ "Keys": [ "Rocket", "Starbuster" ] }

6
Tests/QtAutogen/mocPlugin/StyleB.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "StyleB.hpp"
QStyle* StyleB::create(const QString& key)
{
return 0;
}

15
Tests/QtAutogen/mocPlugin/StyleB.hpp Normal file
View File

@@ -0,0 +1,15 @@
#ifndef STYLEB_HPP
#define STYLEB_HPP
#include <QStylePlugin>
class StyleB : public QStylePlugin
{
Q_OBJECT
// Json file in local subdirectory
Q_PLUGIN_METADATA(IID "org.styles.B" FILE "jsonIn/StyleB.json")
public:
QStyle* create(const QString& key);
};
#endif

6
Tests/QtAutogen/mocPlugin/StyleC.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "StyleC.hpp"
QStyle* StyleC::create(const QString& key)
{
return 0;
}

15
Tests/QtAutogen/mocPlugin/StyleC.hpp Normal file
View File

@@ -0,0 +1,15 @@
#ifndef STYLEC_HPP
#define STYLEC_HPP
#include <QStylePlugin>
class StyleC : public QStylePlugin
{
Q_OBJECT
// Json file in global root directory
Q_PLUGIN_METADATA(IID "org.styles.C" FILE "StyleC.json")
public:
QStyle* create(const QString& key);
};
#endif

6
Tests/QtAutogen/mocPlugin/StyleD.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "StyleD.hpp"
QStyle* StyleD::create(const QString& key)
{
return 0;
}

15
Tests/QtAutogen/mocPlugin/StyleD.hpp Normal file
View File

@@ -0,0 +1,15 @@
#ifndef STYLED_HPP
#define STYLED_HPP
#include <QStylePlugin>
class StyleD : public QStylePlugin
{
Q_OBJECT
// Json file in global sub director
Q_PLUGIN_METADATA(IID "org.styles.D" FILE "sub/StyleD.json")
public:
QStyle* create(const QString& key);
};
#endif

6
Tests/QtAutogen/mocPlugin/StyleE.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "StyleE.hpp"
QStyle* StyleE::create(const QString& key)
{
return 0;
}

15
Tests/QtAutogen/mocPlugin/StyleE.hpp Normal file
View File

@@ -0,0 +1,15 @@
#ifndef STYLEE_HPP
#define STYLEE_HPP
#include <QStylePlugin>
class StyleE : public QStylePlugin
{
Q_OBJECT
// No Json file
Q_PLUGIN_METADATA(IID "org.styles.E")
public:
QStyle* create(const QString& key);
};
#endif

1
Tests/QtAutogen/mocPlugin/jsonIn/StyleB.json Normal file
View File

@@ -0,0 +1 @@
{ "Keys": [ "Rocket", "StarbusterB" ] }

1
Tests/QtAutogen/mocPlugin/jsonIn/StyleC.json Normal file
View File

@@ -0,0 +1 @@
{ "Keys": [ "Rocket", "StarbusterC" ] }

1
Tests/QtAutogen/mocPlugin/jsonIn/StyleD.json Normal file
View File

@@ -0,0 +1 @@
{ "Keys": [ "Rocket", "StarbusterD" ] }

6
Tests/QtAutogen/mocPlugin/main.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "StyleA.hpp"
int main(int argv, char** args)
{
return 0;
}

11
Tests/QtAutogen/sameName/CMakeLists.txt
View File

@@ -18,3 +18,14 @@ add_executable(sameName
)
target_link_libraries(sameName ${QT_LIBRARIES})
set_target_properties(sameName PROPERTIES AUTOMOC TRUE AUTORCC TRUE)
# Set different compression levels
if (QT_TEST_VERSION STREQUAL 4)
set(rccCompress "-compress")
else()
set(rccCompress "--compress")
endif()
set_target_properties(sameName PROPERTIES AUTORCC_OPTIONS "${rccCompress};0" )
set_source_files_properties(aaa/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};1" )
set_source_files_properties(bbb/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};2" )
set_source_files_properties(ccc/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};3" )